WorldName
PruebaEstructura
:
Bedrock
Obsidian
Stack
MAX_VALOR
100
;
Obsidian
Spider
SALUDO
"Prueba de estructura"
;
ResourcePack
Anvil
Stack
->
Spider
;
Inventory
Stack
contador
=
0
;
Spider
mensaje
=
"Hola mundo"
;
Recipe
Spell
sumar
(
Stack
::
a
,
b
)
->
Stack
;
Ritual
mostrarMensaje
(
Spider
::
texto
)
;
CraftingTable
Spell
sumar
(
Stack
::
a
,
b
)
->
Stack
PolloCrudo
Stack
resultado
=
a
+
b
;
respawn
resultado
;
PolloAsado
Ritual
mostrarMensaje
(
Spider
::
texto
)
PolloCrudo
dropperSpider
(
texto
)
;
PolloAsado
SpawnPoint
PolloCrudo
dropperSpider
(
SALUDO
)
;
Stack
resultado
=
sumar
(
5
,
10
)
;
dropperSpider
(
"El resultado es: "
bind
resultado
)
;
PolloAsado
worldSave
WorldName
PruebaTipos
:
Inventory
Stack
entero
=
42
;
Rune
caracter
=
'N'
;
Spider
texto
=
"NotchEngine"
;
Torch
verdadero
=
On
;
Torch
falso
=
Off
;
Chest
numeros
=
{
:
1
,
2
,
3
,
4
,
5
:
}
;
Book
archivo
=
{
"datos.txt"
,
'E'
}
;
Ghast
decimal
=
3.14159
;
Shelf
[
5
]
Stack
arreglo
=
[
1
,
2
,
3
,
4
,
5
]
;
Entity
Jugador
PolloCrudo
Spider
nombre
;
Stack
nivel
;
Ghast
salud
;
PolloAsado
;
Entity
Jugador
jugador
=
{
nombre
:
"Steve"
,
nivel
:
1
,
salud
:
20.0
}
;
SpawnPoint
PolloCrudo
dropperSpider
(
"Prueba de tipos completada"
)
;
PolloAsado
worldSave
WorldName
PruebaBooleanos
:
Bedrock
Obsidian
Torch
VERDADERO
On
;
Obsidian
Torch
FALSO
Off
;
Inventory
Torch
activo
=
On
;
Torch
inactivo
=
Off
;
Torch
resultado1
;
Torch
resultado2
;
Torch
resultado3
;
Torch
resultado4
;
Torch
resultado5
;
SpawnPoint
PolloCrudo
dropperSpider
(
"Valor de On: "
)
;
dropperTorch
(
On
)
;
dropperSpider
(
"Valor de Off: "
)
;
dropperTorch
(
Off
)
;
resultado1
=
On
and
On
;
dropperSpider
(
"On and On: "
)
;
dropperTorch
(
resultado1
)
;
resultado2
=
On
and
Off
;
dropperSpider
(
"On and Off: "
)
;
dropperTorch
(
resultado2
)
;
resultado3
=
On
or
Off
;
dropperSpider
(
"On or Off: "
)
;
dropperTorch
(
resultado3
)
;
resultado4
=
Off
or
Off
;
dropperSpider
(
"Off or Off: "
)
;
dropperTorch
(
resultado4
)
;
resultado5
=
not
On
;
dropperSpider
(
"not On: "
)
;
dropperTorch
(
resultado5
)
;
target
On
craft
hit
PolloCrudo
dropperSpider
(
"Condición On es verdadera"
)
;
PolloAsado
target
Off
craft
hit
PolloCrudo
dropperSpider
(
"Esto no debería mostrarse"
)
;
PolloAsado
miss
PolloCrudo
dropperSpider
(
"Condición Off es falsa"
)
;
PolloAsado
PolloAsado
worldSave
WorldName
PruebaBloques
:
Inventory
Stack
contador
=
0
;
Stack
acumulador
=
0
;
Stack
resultado
=
0
;
Spider
mensaje
=
"Prueba de bloques PolloCrudo y PolloAsado"
;
CraftingTable
Spell
sumarPares
(
Stack
::
limite
)
->
Stack
PolloCrudo
Stack
suma
=
0
;
walk
i
set
1
to
limite
craft
PolloCrudo
target
i
%
2
is
0
craft
hit
PolloCrudo
suma
+
=
i
;
PolloAsado
PolloAsado
respawn
suma
;
PolloAsado
Spell
calcularFactorial
(
Stack
::
n
)
->
Stack
PolloCrudo
target
n
<=
1
craft
hit
PolloCrudo
respawn
1
;
PolloAsado
Stack
resultado
=
n
*
calcularFactorial
(
n
-
1
)
;
respawn
resultado
;
PolloAsado
SpawnPoint
PolloCrudo
PolloCrudo
contador
=
5
;
dropperSpider
(
mensaje
)
;
PolloAsado
repeater
contador
>
0
craft
PolloCrudo
acumulador
+
=
contador
;
magma
contador
;
target
contador
is
2
craft
hit
PolloCrudo
dropperSpider
(
"Contador es igual a 2"
)
;
PolloCrudo
dropperSpider
(
"Este es un bloque muy anidado"
)
;
PolloAsado
PolloAsado
PolloAsado
target
acumulador
>
10
craft
hit
PolloCrudo
dropperSpider
(
"Acumulador es mayor que 10"
)
;
PolloAsado
miss
PolloCrudo
dropperSpider
(
"Acumulador es menor o igual a 10"
)
;
PolloAsado
spawner
PolloCrudo
soulsand
resultado
;
target
resultado
>
5
craft
hit
creeper
;
PolloAsado
exhausted
resultado
>
10
;
dropperSpider
(
"Valor final del resultado: "
bind
resultado
)
;
PolloAsado
worldSave
WorldName
PruebaControl
:
Inventory
Stack
contador
=
0
;
Stack
opcion
=
2
;
Torch
condicion
=
On
;
Stack
iterador
=
0
;
Entity
Punto
PolloCrudo
Stack
x
;
Stack
y
;
PolloAsado
;
Entity
Punto
coordenada
;
SpawnPoint
PolloCrudo
dropperSpider
(
"Prueba de repeater:"
)
;
contador
=
5
;
repeater
contador
>
0
craft
PolloCrudo
dropperStack
(
contador
)
;
magma
contador
;
PolloAsado
dropperSpider
(
"Prueba de target con hit y miss:"
)
;
target
condicion
craft
hit
PolloCrudo
dropperSpider
(
"Condición es verdadera"
)
;
PolloAsado
miss
PolloCrudo
dropperSpider
(
"Condición es falsa"
)
;
PolloAsado
dropperSpider
(
"Prueba de jukebox con disc y silence:"
)
;
jukebox
opcion
craft
disc
1
:
PolloCrudo
dropperSpider
(
"Opción 1 seleccionada"
)
;
PolloAsado
disc
2
:
PolloCrudo
dropperSpider
(
"Opción 2 seleccionada"
)
;
PolloAsado
silence
:
PolloCrudo
dropperSpider
(
"Ninguna opción válida seleccionada"
)
;
PolloAsado
dropperSpider
(
"Prueba de spawner con exhausted:"
)
;
contador
=
0
;
spawner
PolloCrudo
soulsand
contador
;
dropperStack
(
contador
)
;
PolloAsado
exhausted
contador
>=
3
;
dropperSpider
(
"Prueba de walk con set, to, step:"
)
;
walk
i
set
0
to
10
step
2
craft
PolloCrudo
dropperStack
(
i
)
;
PolloAsado
dropperSpider
(
"Prueba de wither:"
)
;
coordenada
@
x
=
10
;
coordenada
@
y
=
20
;
wither
coordenada
craft
PolloCrudo
dropperSpider
(
"Coordenadas: ("
bind
x
bind
", "
bind
y
bind
")"
)
;
PolloAsado
PolloAsado
worldSave
WorldName
PruebaSaltos
:
Inventory
Stack
contador
=
0
;
Stack
totalPares
=
0
;
Stack
totalImpares
=
0
;
Torch
errorCritico
=
Off
;
SpawnPoint
PolloCrudo
dropperSpider
(
"Prueba de creeper (break):"
)
;
walk
i
set
1
to
10
craft
PolloCrudo
dropperSpider
(
"Iteración: "
bind
i
)
;
target
i
is
5
craft
hit
PolloCrudo
dropperSpider
(
"Encontrado 5, saliendo del bucle con creeper"
)
;
creeper
;
PolloAsado
PolloAsado
dropperSpider
(
"Prueba de enderPearl (continue):"
)
;
walk
i
set
1
to
10
craft
PolloCrudo
target
i
%
2
is
0
craft
hit
PolloCrudo
dropperSpider
(
"Número par "
bind
i
bind
", saltando con enderPearl"
)
;
enderPearl
;
PolloAsado
dropperSpider
(
"Procesando número impar: "
bind
i
)
;
totalImpares
+
=
i
;
PolloAsado
dropperSpider
(
"Total de números impares: "
bind
totalImpares
)
;
dropperSpider
(
"Prueba de control de flujo en bucles anidados:"
)
;
walk
i
set
1
to
5
craft
PolloCrudo
walk
j
set
1
to
5
craft
PolloCrudo
target
j
is
3
craft
hit
PolloCrudo
dropperSpider
(
"Saltando j=3 con enderPearl"
)
;
enderPearl
;
PolloAsado
target
j
is
4
craft
hit
PolloCrudo
dropperSpider
(
"Saliendo del bucle interno con creeper en j=4"
)
;
creeper
;
PolloAsado
dropperSpider
(
"i="
bind
i
bind
", j="
bind
j
)
;
PolloAsado
PolloAsado
dropperSpider
(
"Prueba de ragequit (halt):"
)
;
target
errorCritico
craft
hit
PolloCrudo
dropperSpider
(
"Error crítico detectado, terminando programa con ragequit"
)
;
PolloAsado
dropperSpider
(
"Esta línea se mostrará si errorCritico es Off"
)
;
target
Off
craft
hit
PolloCrudo
dropperSpider
(
"Esta condición nunca se cumple"
)
;
ragequit
;
PolloAsado
PolloAsado
worldSave
WorldName
PruebaFunciones
:
Recipe
Spell
sumar
(
Stack
::
a
,
b
)
->
Stack
;
Spell
factorial
(
Stack
::
n
)
->
Stack
;
Spell
esPar
(
Stack
::
numero
)
->
Torch
;
Spell
sumarArreglo
(
Shelf
[
10
]
Stack
::
numeros
;
Stack
tamano
)
->
Stack
;
Ritual
imprimirLinea
(
Spider
::
texto
)
;
Ritual
mostrarResultado
(
Spider
::
operacion
;
Stack
valor
)
;
Ritual
imprimirArreglo
(
Shelf
[
10
]
Stack
::
arr
;
Stack
tamano
)
;
CraftingTable
Spell
sumar
(
Stack
::
a
,
b
)
->
Stack
PolloCrudo
respawn
a
+
b
;
PolloAsado
Spell
factorial
(
Stack
::
n
)
->
Stack
PolloCrudo
target
n
<=
1
craft
hit
PolloCrudo
respawn
1
;
PolloAsado
respawn
n
*
factorial
(
n
-
1
)
;
PolloAsado
Spell
esPar
(
Stack
::
numero
)
->
Torch
PolloCrudo
target
numero
%
2
is
0
craft
hit
PolloCrudo
respawn
On
;
PolloAsado
miss
PolloCrudo
respawn
Off
;
PolloAsado
PolloAsado
Spell
sumarArreglo
(
Shelf
[
10
]
Stack
::
numeros
;
Stack
tamano
)
->
Stack
PolloCrudo
Stack
suma
=
0
;
target
tamano
<=
0
craft
hit
PolloCrudo
respawn
0
;
PolloAsado
walk
i
set
0
to
tamano
-
1
craft
PolloCrudo
suma
+
=
numeros
[
i
]
;
PolloAsado
respawn
suma
;
PolloAsado
Ritual
imprimirLinea
(
Spider
::
texto
)
PolloCrudo
dropperSpider
(
texto
)
;
dropperSpider
(
"------------------------"
)
;
PolloAsado
Ritual
mostrarResultado
(
Spider
::
operacion
;
Stack
valor
)
PolloCrudo
dropperSpider
(
operacion
bind
": "
bind
valor
)
;
target
valor
<
0
craft
hit
PolloCrudo
dropperSpider
(
"¡Valor negativo!"
)
;
respawn
;
PolloAsado
dropperSpider
(
"Valor válido procesado"
)
;
PolloAsado
Ritual
imprimirArreglo
(
Shelf
[
10
]
Stack
::
arr
;
Stack
tamano
)
PolloCrudo
target
tamano
<=
0
craft
hit
PolloCrudo
dropperSpider
(
"Arreglo vacío"
)
;
respawn
;
PolloAsado
dropperSpider
(
"Elementos del arreglo:"
)
;
walk
i
set
0
to
tamano
-
1
craft
PolloCrudo
dropperStack
(
arr
[
i
]
)
;
PolloAsado
PolloAsado
SpawnPoint
PolloCrudo
Stack
a
=
5
;
Stack
b
=
7
;
Stack
resultado
;
Shelf
[
10
]
Stack
numeros
;
walk
i
set
0
to
9
craft
PolloCrudo
numeros
[
i
]
=
i
+
1
;
PolloAsado
resultado
=
sumar
(
a
,
b
)
;
dropperSpider
(
"Suma: "
bind
resultado
)
;
resultado
=
factorial
(
5
)
;
dropperSpider
(
"Factorial de 5: "
bind
resultado
)
;
Torch
esPar5
=
esPar
(
5
)
;
dropperSpider
(
"¿Es 5 par?: "
)
;
dropperTorch
(
esPar5
)
;
resultado
=
sumarArreglo
(
numeros
,
10
)
;
dropperSpider
(
"Suma del arreglo: "
bind
resultado
)
;
imprimirLinea
(
"==== Resultados de pruebas ===="
)
;
mostrarResultado
(
"Suma de 5 y 7"
,
sumar
(
a
,
b
)
)
;
mostrarResultado
(
"Valor negativo"
,
-
10
)
;
imprimirArreglo
(
numeros
,
5
)
;
imprimirArreglo
(
numeros
,
0
)
;
PolloAsado
worldSave
WorldName
PruebaOperadores
:
Inventory
{
Stack
contador
=
5
;
Torch
condicion1
=
On
;
Torch
condicion2
=
Off
;
Torch
resultado
;
Spider
texto1
=
"Notch"
;
Spider
texto2
=
"Engine"
;
Spider
textoCompleto
;
Rune
letra
=
'a'
;
Rune
letraMayuscula
;
Chest
conjunto1
=
{
:
1
,
2
,
3
:
}
;
Chest
conjunto2
=
{
:
3
,
4
,
5
:
}
;
Chest
conjuntoResultado
;
Book
archivo1
=
{
"datos.txt"
,
'E'
}
;
Book
archivo2
=
{
"resultado.txt"
,
'E'
}
;
Ghast
flotante1
=
3.5
;
Ghast
flotante2
=
2.5
;
Ghast
resultadoFlotante
;
}
SpawnPoint
{
PolloCrudo
soulsand
contador
;
magma
contador
;
resultado
=
condicion1
and
condicion2
;
resultado
=
condicion1
or
condicion2
;
resultado
=
not
condicion1
;
resultado
=
condicion1
xor
condicion2
;
textoCompleto
=
bind
(
texto1
,
" "
bind
texto2
)
;
Stack
longitud
=
#
(
textoCompleto
)
;
Spider
subcadena
=
from
textoCompleto
#
#
0
#
#
5
;
Spider
sinNotch
=
except
textoCompleto
#
#
0
#
#
6
;
Stack
posicion
=
seek
(
textoCompleto
,
"Engine"
)
;
Torch
esLetra
=
isEngraved
(
letra
)
;
Torch
esDigito
=
isInscribed
(
letra
)
;
letraMayuscula
=
etchUp
(
letra
)
;
Rune
letraMinuscula
=
etchDown
(
letraMayuscula
)
;
add
(
conjunto1
,
4
)
;
drop
(
conjunto1
,
2
)
;
conjuntoResultado
=
feed
(
conjunto1
,
conjunto2
)
;
resultado
=
map
(
conjunto1
,
3
)
;
Torch
conjuntoVacio
=
void
(
conjunto1
)
;
unlock
(
archivo1
)
;
forge
(
archivo1
,
"Texto de prueba"
)
;
lock
(
archivo1
)
;
Book
nuevoArchivo
=
make
(
{
"nuevo.txt"
,
'E'
}
)
;
forge
(
nuevoArchivo
,
"Contenido del nuevo archivo"
)
;
lock
(
nuevoArchivo
)
;
unlock
(
archivo1
)
;
unlock
(
nuevoArchivo
)
;
expand
(
archivo1
,
nuevoArchivo
)
;
lock
(
archivo1
)
;
lock
(
nuevoArchivo
)
;
resultadoFlotante
=
flotante1
:
+
flotante2
;
resultadoFlotante
=
flotante1
:
-
flotante2
;
resultadoFlotante
=
flotante1
:
*
flotante2
;
resultadoFlotante
=
flotante1
:
flotante2
;
resultadoFlotante
=
flotante1
:
%
flotante2
;
PolloAsado
}
worldSave
WorldName
PruebaLitEnteros
:
Bedrock
Obsidian
Stack
CERO
0
;
Obsidian
Stack
POSITIVO
42
;
Obsidian
Stack
NEGATIVO
-
42
;
Obsidian
Stack
MAX_VALOR
2147483647
;
Obsidian
Stack
MIN_VALOR
-
2147483648
;
Inventory
Stack
cero
=
0
;
Stack
uno
=
1
;
Stack
diez
=
10
;
Stack
cien
=
100
;
Stack
mil
=
1000
;
Stack
millon
=
1000000
;
Stack
negUno
=
-
1
;
Stack
negDiez
=
-
10
;
Stack
negCien
=
-
100
;
Stack
negMil
=
-
1000
;
Stack
negMillon
=
-
1000000
;
Stack
maxInt
=
2147483647
;
Stack
minInt
=
-
2147483648
;
Stack
resultado
=
0
;
SpawnPoint
PolloCrudo
resultado
=
5
+
3
;
dropperSpider
(
"5 + 3 = "
bind
resultado
)
;
resultado
=
10
-
7
;
dropperSpider
(
"10 - 7 = "
bind
resultado
)
;
resultado
=
6
*
4
;
dropperSpider
(
"6 * 4 = "
bind
resultado
)
;
resultado
=
20
4
;
dropperSpider
(
"20 // 4 = "
bind
resultado
)
;
resultado
=
17
%
5
;
dropperSpider
(
"17 % 5 = "
bind
resultado
)
;
resultado
=
(
5
+
3
)
*
2
-
4
2
;
dropperSpider
(
"(5 + 3) * 2 - 4 // 2 = "
bind
resultado
)
;
resultado
=
-
5
+
10
;
dropperSpider
(
"-5 + 10 = "
bind
resultado
)
;
resultado
=
5
+
-
10
;
dropperSpider
(
"5 + -10 = "
bind
resultado
)
;
resultado
=
-
5
*
-
4
;
dropperSpider
(
"-5 * -4 = "
bind
resultado
)
;
walk
i
set
1
to
5
craft
PolloCrudo
dropperSpider
(
"Iteración: "
bind
i
)
;
PolloAsado
target
10
>
5
craft
hit
PolloCrudo
dropperSpider
(
"10 es mayor que 5"
)
;
PolloAsado
target
0
is
0
craft
hit
PolloCrudo
dropperSpider
(
"0 es igual a 0"
)
;
PolloAsado
target
-
10
<
-
5
craft
hit
PolloCrudo
dropperSpider
(
"-10 es menor que -5"
)
;
PolloAsado
dropperSpider
(
"Valor máximo de entero: "
bind
maxInt
)
;
dropperSpider
(
"Valor mínimo de entero: "
bind
minInt
)
;
target
0
is
cero
craft
hit
PolloCrudo
dropperSpider
(
"Ambas representaciones de cero son iguales"
)
;
PolloAsado
PolloAsado
worldSave
WorldName
PruebaLitFlotantes
:
Bedrock
Obsidian
Ghast
CERO_PUNTO_CERO
0.0
;
Obsidian
Ghast
PI
3.14159
;
Obsidian
Ghast
E
2.71828
;
Obsidian
Ghast
NEG_PI
-
3.14159
;
Obsidian
Ghast
GRAVEDAD
-
9.8
;
Inventory
Ghast
decimal1
=
0.5
;
Ghast
decimal2
=
1.25
;
Ghast
decimal3
=
3.14159
;
Ghast
decimal4
=
2.71828
;
Ghast
decimal5
=
123.456
;
Ghast
negDecimal1
=
-
0.5
;
Ghast
negDecimal2
=
-
1.25
;
Ghast
negDecimal3
=
-
3.14159
;
Ghast
negDecimal4
=
-
2.71828
;
Ghast
negDecimal5
=
-
123.456
;
Ghast
decimal6
=
.
5
;
Ghast
decimal7
=
5
.
;
Ghast
precisionAlta
=
1.123456789012345
;
Ghast
muyPequeno
=
0.0000001
;
Ghast
muyGrande
=
1000000.0
;
Ghast
resultado
=
0.0
;
SpawnPoint
PolloCrudo
resultado
=
5.5
:
+
3.5
;
dropperSpider
(
"5.5 :+ 3.5 = "
)
;
dropperGhast
(
resultado
)
;
resultado
=
10.75
:
-
7.25
;
dropperSpider
(
"10.75 :- 7.25 = "
)
;
dropperGhast
(
resultado
)
;
resultado
=
6.5
:
*
2.0
;
dropperSpider
(
"6.5 :* 2.0 = "
)
;
dropperGhast
(
resultado
)
;
resultado
=
20.0
:
4.0
;
dropperSpider
(
"20.0 :// 4.0 = "
)
;
dropperGhast
(
resultado
)
;
resultado
=
7.5
:
%
2.0
;
dropperSpider
(
"7.5 :% 2.0 = "
)
;
dropperGhast
(
resultado
)
;
resultado
=
.
5
:
+
2
.
;
dropperSpider
(
".5 :+ 2. = "
)
;
dropperGhast
(
resultado
)
;
resultado
=
-
5.5
:
+
10.0
;
dropperSpider
(
"-5.5 :+ 10.0 = "
)
;
dropperGhast
(
resultado
)
;
resultado
=
5.0
:
+
-
10.0
;
dropperSpider
(
"5.0 :+ -10.0 = "
)
;
dropperGhast
(
resultado
)
;
resultado
=
-
5.0
:
*
-
4.0
;
dropperSpider
(
"-5.0 :* -4.0 = "
)
;
dropperGhast
(
resultado
)
;
resultado
=
(
2.5
:
+
1.5
)
:
*
3.0
:
-
5.0
:
2.0
;
dropperSpider
(
"(2.5 :+ 1.5) :* 3.0 :- 5.0 :// 2.0 = "
)
;
dropperGhast
(
resultado
)
;
target
3.14
>
3.0
craft
hit
PolloCrudo
dropperSpider
(
"3.14 es mayor que 3.0"
)
;
PolloAsado
target
0.1
:
+
0.2
isNot
0.3
craft
hit
PolloCrudo
dropperSpider
(
"0.1 + 0.2 no es exactamente igual a 0.3 (error de precisión)"
)
;
dropperGhast
(
0.1
:
+
0.2
)
;
PolloAsado
Stack
entero
=
3.14159
>
>
Stack
;
dropperSpider
(
"PI truncado a entero: "
bind
entero
)
;
dropperSpider
(
"Valor de PI: "
)
;
dropperGhast
(
PI
)
;
dropperSpider
(
"Número con alta precisión: "
)
;
dropperGhast
(
precisionAlta
)
;
dropperSpider
(
"Número muy pequeño: "
)
;
dropperGhast
(
muyPequeno
)
;
dropperSpider
(
"Número muy grande: "
)
;
dropperGhast
(
muyGrande
)
;
PolloAsado
worldSave
WorldName
PruebaLitCaracteres
:
Bedrock
Obsidian
Rune
LETRA_A
'A'
;
Obsidian
Rune
LETRA_Z
'Z'
;
Obsidian
Rune
DIGITO_0
'0'
;
Obsidian
Rune
DIGITO_9
'9'
;
Obsidian
Rune
NUEVA_LINEA
'\n'
;
Obsidian
Rune
TABULACION
'\t'
;
Inventory
Rune
letraA
=
'A'
;
Rune
letraB
=
'B'
;
Rune
letraC
=
'C'
;
Rune
letraZ
=
'Z'
;
Rune
letraMina
=
'a'
;
Rune
letraMinb
=
'b'
;
Rune
letraMinc
=
'c'
;
Rune
letraMinz
=
'z'
;
Rune
digito0
=
'0'
;
Rune
digito1
=
'1'
;
Rune
digito5
=
'5'
;
Rune
digito9
=
'9'
;
Rune
simboloExclamacion
=
'!'
;
Rune
simboloInterrogacion
=
'?'
;
Rune
simboloArroba
=
'@'
;
Rune
simboloNumeral
=
'#'
;
Rune
simboloDolar
=
'$'
;
Rune
simboloPorcentaje
=
'%'
;
Rune
simboloAmpersand
=
'&'
;
Rune
simboloAsterisco
=
'*'
;
Rune
simboloParentesisIzq
=
'('
;
Rune
simboloParentesisDer
=
')'
;
Rune
simboloGuion
=
'-'
;
Rune
simboloGuionBajo
=
'_'
;
Rune
simboloIgual
=
'='
;
Rune
simboloMas
=
'+'
;
Rune
simboloCorcheteIzq
=
'['
;
Rune
simboloCorcheteDer
=
']'
;
Rune
simboloLlaveIzq
=
'{'
;
Rune
simboloLlaveDer
=
'}'
;
Rune
simboloPuntoyComa
=
';'
;
Rune
simboloDosPuntos
=
':'
;
Rune
simboloComillaSimple
=
'\''
;
Rune
simboloComillaDoble
=
'"'
;
Rune
simboloBarra
=
'/'
;
Rune
simboloBarraInversa
=
'\\'
;
Rune
simboloBarraVertical
=
'|'
;
Rune
simboloComa
=
','
;
Rune
simboloPunto
=
'.'
;
Rune
simboloMenorQue
=
'<'
;
Rune
simboloMayorQue
=
'>'
;
Rune
escapeNuevaLinea
=
'\n'
;
Rune
escapeTabulacion
=
'\t'
;
Rune
escapeRetornoCarro
=
'\r'
;
Rune
escapeBarraInversa
=
'\\'
;
Rune
escapeComillaSimple
=
'\''
;
Rune
escapeComillaDoble
=
'\"'
;
SpawnPoint
PolloCrudo
dropperSpider
(
"Letras mayúsculas: "
)
;
dropperRune
(
letraA
)
;
dropperRune
(
letraB
)
;
dropperRune
(
letraC
)
;
dropperSpider
(
"Letras minúsculas: "
)
;
dropperRune
(
letraMina
)
;
dropperRune
(
letraMinb
)
;
dropperRune
(
letraMinc
)
;
dropperSpider
(
"Dígitos: "
)
;
dropperRune
(
digito0
)
;
dropperRune
(
digito1
)
;
dropperRune
(
digito5
)
;
dropperRune
(
digito9
)
;
dropperSpider
(
"Símbolos: "
)
;
dropperRune
(
simboloExclamacion
)
;
dropperRune
(
simboloInterrogacion
)
;
dropperRune
(
simboloArroba
)
;
dropperRune
(
simboloNumeral
)
;
Spider
texto
=
"NotchEngine"
;
Rune
primerCaracter
=
texto
[
0
]
;
Rune
ultimoCaracter
=
texto
[
10
]
;
dropperSpider
(
"Primer carácter de 'NotchEngine': "
)
;
dropperRune
(
primerCaracter
)
;
dropperSpider
(
"Último carácter de 'NotchEngine': "
)
;
dropperRune
(
ultimoCaracter
)
;
Rune
letraMinuscula
=
'a'
;
Rune
letraMayuscula
=
etchUp
(
letraMinuscula
)
;
dropperSpider
(
"Minúscula: "
)
;
dropperRune
(
letraMinuscula
)
;
dropperSpider
(
"Convertida a mayúscula: "
)
;
dropperRune
(
letraMayuscula
)
;
letraMinuscula
=
etchDown
(
letraMayuscula
)
;
dropperSpider
(
"Convertida nuevamente a minúscula: "
)
;
dropperRune
(
letraMinuscula
)
;
Torch
esLetra
=
isEngraved
(
'A'
)
;
Torch
esDigito
=
isInscribed
(
'5'
)
;
dropperSpider
(
"¿'A' es una letra? "
)
;
dropperTorch
(
esLetra
)
;
dropperSpider
(
"¿'5' es un dígito? "
)
;
dropperTorch
(
esDigito
)
;
esLetra
=
isEngraved
(
'7'
)
;
esDigito
=
isInscribed
(
'K'
)
;
dropperSpider
(
"¿'7' es una letra? "
)
;
dropperTorch
(
esLetra
)
;
dropperSpider
(
"¿'K' es un dígito? "
)
;
dropperTorch
(
esDigito
)
;
Stack
valorAsciiA
=
letraA
>
>
Stack
;
dropperSpider
(
"Valor ASCII de 'A': "
bind
valorAsciiA
)
;
PolloAsado
worldSave
WorldName
PruebaLitStrings
:
Bedrock
Obsidian
Spider
VACIO
""
;
Obsidian
Spider
ESPACIO
" "
;
Obsidian
Spider
SALUDO
"Hola Mundo"
;
Obsidian
Spider
CON_COMILLAS
"Este string tiene \"comillas\""
;
Obsidian
Spider
MULTILINEA
"Primera línea\nSegunda línea"
;
Inventory
Spider
cadenaVacia
=
""
;
Spider
espacioSimple
=
" "
;
Spider
cadenaSimple
=
"Texto simple"
;
Spider
conNumeros
=
"Notch Engine v1.0"
;
Spider
conSimbolos
=
"¡Hola, mundo! ¿Cómo estás?"
;
Spider
conCaracteresEspeciales
=
"#$%&/()=?¡"
;
Spider
conNuevaLinea
=
"Primera línea\nSegunda línea"
;
Spider
conTabulacion
=
"Columna1\tColumna2\tColumna3"
;
Spider
conRetornoCarro
=
"Texto con\rretorno de carro"
;
Spider
conBarraInversa
=
"Ruta de archivo: C:\\Archivos\\datos.txt"
;
Spider
conComillasSimples
=
"Texto con 'comillas simples'"
;
Spider
conComillasDobles
=
"Texto con \"comillas dobles\""
;
Spider
mixto
=
"Abc123!@#\n\t\"'"
;
Spider
cadenaLarga
=
"Esta es una cadena de texto más larga que contiene múltiples palabras, números como 12345, y símbolos como $%&. Es útil para probar el manejo de cadenas extensas en el analizador léxico y asegurarse de que no hay limitaciones inesperadas en la longitud de las cadenas."
;
Spider
prefijo
=
"Notch"
;
Spider
sufijo
=
"Engine"
;
Spider
resultado
;
SpawnPoint
PolloCrudo
dropperSpider
(
"Cadena simple: "
bind
cadenaSimple
)
;
dropperSpider
(
"Cadena con números: "
bind
conNumeros
)
;
dropperSpider
(
"Cadena con símbolos: "
bind
conSimbolos
)
;
resultado
=
bind
(
prefijo
,
" "
bind
sufijo
)
;
dropperSpider
(
"Concatenación: "
bind
resultado
)
;
Stack
longitud
=
#
(
resultado
)
;
dropperSpider
(
"Longitud de '"
bind
resultado
bind
"': "
bind
longitud
)
;
Spider
subcadena
=
from
resultado
#
#
0
#
#
5
;
dropperSpider
(
"Subcadena (0, 5): "
bind
subcadena
)
;
Spider
sinNotch
=
except
resultado
#
#
0
#
#
6
;
dropperSpider
(
"Sin los primeros 6 caracteres: "
bind
sinNotch
)
;
Stack
posicion
=
seek
(
resultado
,
"Engine"
)
;
dropperSpider
(
"Posición de 'Engine': "
bind
posicion
)
;
Rune
primerCaracter
=
resultado
[
0
]
;
dropperSpider
(
"Primer carácter: "
)
;
dropperRune
(
primerCaracter
)
;
Rune
ultimoCaracter
=
resultado
[
11
]
;
dropperSpider
(
"Último carácter: "
)
;
dropperRune
(
ultimoCaracter
)
;
dropperSpider
(
"Cadena con nueva línea:"
)
;
dropperSpider
(
conNuevaLinea
)
;
dropperSpider
(
"Cadena con tabulaciones:"
)
;
dropperSpider
(
conTabulacion
)
;
dropperSpider
(
"Cadena con comillas dobles:"
)
;
dropperSpider
(
conComillasDobles
)
;
dropperSpider
(
"Cadena larga:"
)
;
dropperSpider
(
cadenaLarga
)
;
target
cadenaVacia
is
""
craft
hit
PolloCrudo
dropperSpider
(
"La cadena está vacía"
)
;
PolloAsado
target
SALUDO
is
"Hola Mundo"
craft
hit
PolloCrudo
dropperSpider
(
"Las cadenas son iguales"
)
;
PolloAsado
PolloAsado
worldSave
WorldName
PruebaLitArreglos
:
Bedrock
Inventory
Shelf
[
5
]
Stack
numerosSimples
=
[
1
,
2
,
3
,
4
,
5
]
;
Shelf
[
3
]
Stack
numerosNegativos
=
[
-
10
,
-
20
,
-
30
]
;
Shelf
[
4
]
Stack
numerosMixtos
=
[
-
2
,
0
,
2
,
4
]
;
Shelf
[
1
]
Stack
unicoElemento
=
[
42
]
;
Shelf
[
0
]
Stack
arregloVacio
=
[
]
;
Shelf
[
5
]
Rune
vocales
=
[
'a'
,
'e'
,
'i'
,
'o'
,
'u'
]
;
Shelf
[
5
]
Rune
simbolos
=
[
'!'
,
'@'
,
'#'
,
'$'
,
'%'
]
;
Shelf
[
3
]
Spider
nombres
=
[
"Steve"
,
"Alex"
,
"Herobrine"
]
;
Shelf
[
4
]
Spider
diasSemana
=
[
"Lunes"
,
"Martes"
,
"Miércoles"
,
"Jueves"
]
;
Shelf
[
4
]
Torch
flags
=
[
On
,
Off
,
On
,
On
]
;
Shelf
[
3
]
Ghast
decimales
=
[
3.14
,
2.71
,
1.618
]
;
Shelf
[
3
]
Shelf
[
3
]
Stack
matriz
=
[
[
1
,
2
,
3
]
,
[
4
,
5
,
6
]
,
[
7
,
8
,
9
]
]
;
Shelf
[
2
]
Shelf
[
2
]
Shelf
[
2
]
Stack
cubo
=
[
[
[
1
,
2
]
,
[
3
,
4
]
]
,
[
[
5
,
6
]
,
[
7
,
8
]
]
]
;
Stack
suma
=
0
;
Stack
elementoActual
=
0
;
SpawnPoint
PolloCrudo
elementoActual
=
numerosSimples
[
0
]
;
dropperSpider
(
"Primer elemento del arreglo: "
bind
elementoActual
)
;
elementoActual
=
numerosSimples
[
4
]
;
dropperSpider
(
"Último elemento del arreglo: "
bind
elementoActual
)
;
numerosSimples
[
2
]
=
30
;
dropperSpider
(
"Elemento modificado: "
bind
numerosSimples
[
2
]
)
;
suma
=
0
;
walk
i
set
0
to
4
craft
PolloCrudo
suma
+
=
numerosSimples
[
i
]
;
dropperSpider
(
"Elemento "
bind
i
bind
": "
bind
numerosSimples
[
i
]
)
;
PolloAsado
dropperSpider
(
"Suma de todos los elementos: "
bind
suma
)
;
dropperSpider
(
"Vocales: "
)
;
walk
i
set
0
to
4
craft
PolloCrudo
dropperRune
(
vocales
[
i
]
)
;
PolloAsado
dropperSpider
(
"Nombres: "
)
;
walk
i
set
0
to
2
craft
PolloCrudo
dropperSpider
(
nombres
[
i
]
)
;
PolloAsado
dropperSpider
(
"Flags: "
)
;
walk
i
set
0
to
3
craft
PolloCrudo
dropperTorch
(
flags
[
i
]
)
;
PolloAsado
dropperSpider
(
"Decimales: "
)
;
walk
i
set
0
to
2
craft
PolloCrudo
dropperGhast
(
decimales
[
i
]
)
;
PolloAsado
elementoActual
=
matriz
[
1
]
[
1
]
;
dropperSpider
(
"Elemento central de la matriz: "
bind
elementoActual
)
;
matriz
[
0
]
[
2
]
=
10
;
dropperSpider
(
"Elemento modificado de la matriz: "
bind
matriz
[
0
]
[
2
]
)
;
dropperSpider
(
"Matriz completa:"
)
;
walk
i
set
0
to
2
craft
PolloCrudo
walk
j
set
0
to
2
craft
PolloCrudo
dropperStack
(
matriz
[
i
]
[
j
]
)
;
PolloAsado
dropperSpider
(
""
)
;
PolloAsado
elementoActual
=
cubo
[
1
]
[
0
]
[
1
]
;
dropperSpider
(
"Elemento de cubo [1][0][1]: "
bind
elementoActual
)
;
Shelf
[
4
]
Stack
fibonacci
=
[
1
,
1
,
2
,
3
]
;
dropperSpider
(
"Fibonacci: "
)
;
walk
i
set
0
to
3
craft
PolloCrudo
dropperStack
(
fibonacci
[
i
]
)
;
PolloAsado
PolloAsado
worldSave
WorldName
PruebaLitRegistros
:
Inventory
Entity
Jugador
PolloCrudo
Spider
nombre
;
Stack
nivel
;
Ghast
salud
;
Torch
activo
;
PolloAsado
;
Entity
Coordenada
PolloCrudo
Stack
x
;
Stack
y
;
Stack
z
;
PolloAsado
;
Entity
Configuracion
PolloCrudo
Torch
modoDebug
;
Stack
volumen
;
Spider
idioma
;
PolloAsado
;
Entity
Jugador
steve
=
{
nombre
:
"Steve"
,
nivel
:
1
,
salud
:
20.0
,
activo
:
On
}
;
Entity
Jugador
alex
=
{
nombre
:
"Alex"
,
nivel
:
2
,
salud
:
18.5
,
activo
:
On
}
;
Entity
Coordenada
posicion
=
{
x
:
10
,
y
:
20
,
z
:
30
}
;
Entity
Configuracion
config
=
{
modoDebug
:
Off
,
volumen
:
75
,
idioma
:
"Español"
}
;
Entity
Jugador
jugadorVacio
=
{
}
;
Entity
Coordenada
origen
=
{
x
:
0
}
;
Entity
Coordenada
punto
=
{
x
:
5
+
5
,
y
:
10
*
2
,
z
:
100
2
}
;
SpawnPoint
PolloCrudo
dropperSpider
(
steve
@
nombre
)
;
dropperStack
(
posicion
@
x
)
;
dropperTorch
(
config
@
modoDebug
)
;
steve
@
nivel
=
5
;
posicion
@
z
=
50
;
Stack
nivelTotal
=
steve
@
nivel
+
alex
@
nivel
;
dropperStack
(
nivelTotal
)
;
wither
steve
craft
PolloCrudo
dropperSpider
(
"Nombre: "
bind
nombre
)
;
dropperStack
(
nivel
)
;
dropperGhast
(
salud
)
;
PolloAsado
Entity
Jugador
herobrine
=
{
nombre
:
"Herobrine"
,
nivel
:
100
,
salud
:
1000.0
,
activo
:
On
}
;
Entity
Coordenada
pos2
=
{
x
:
100
,
y
:
200
,
z
:
300
}
;
PolloAsado
worldSave
WorldName
PruebaLitConjuntos
:
Inventory
Chest
numeros
=
{
:
1
,
2
,
3
,
4
,
5
:
}
;
Chest
primos
=
{
:
2
,
3
,
5
,
7
,
11
,
13
,
17
,
19
:
}
;
Chest
pares
=
{
:
2
,
4
,
6
,
8
,
10
:
}
;
Chest
vocales
=
{
:
'a'
,
'e'
,
'i'
,
'o'
,
'u'
:
}
;
Chest
consonantes
=
{
:
'b'
,
'c'
,
'd'
,
'f'
,
'g'
:
}
;
Chest
nombres
=
{
:
"Steve"
,
"Alex"
,
"Herobrine"
,
"Notch"
:
}
;
Chest
herramientas
=
{
:
"Espada"
,
"Pico"
,
"Hacha"
,
"Pala"
:
}
;
Chest
vacio
=
{
:
:
}
;
Chest
singleton
=
{
:
42
:
}
;
Chest
mezcla
=
{
:
1
,
'a'
,
"texto"
:
}
;
Chest
calculados
=
{
:
1
+
1
,
2
*
2
,
10
2
:
}
;
Chest
booleanos
=
{
:
On
,
Off
:
}
;
SpawnPoint
PolloCrudo
add
(
numeros
,
6
)
;
dropperSpider
(
"Después de add(numeros, 6):"
)
;
drop
(
primos
,
2
)
;
dropperSpider
(
"Después de drop(primos, 2):"
)
;
Chest
union
=
feed
(
numeros
,
primos
)
;
dropperSpider
(
"Unión de numeros y primos:"
)
;
Chest
interseccion
=
map
(
numeros
,
pares
)
;
dropperSpider
(
"Intersección de numeros y pares:"
)
;
Torch
contiene
=
biom
(
vocales
,
'a'
)
;
dropperTorch
(
contiene
)
;
Torch
esVacio
=
void
(
vacio
)
;
dropperTorch
(
esVacio
)
;
Chest
conEspacios
=
{
:
'a'
,
'b'
,
'c'
:
}
;
Chest
conComentarios
=
{
:
1
,
2
,
3
:
}
;
Chest
{
:
1
,
'x'
,
"y"
:
}
;
PolloAsado
worldSave
WorldName
PruebaLitArchivos
:
Inventory
Book
archivoConfiguracion
=
{
"config.txt"
,
'L'
}
;
Book
archivoJugadores
=
{
"jugadores.dat"
,
'L'
}
;
Book
archivoNiveles
=
{
"niveles/nivel1.map"
,
'L'
}
;
Book
archivoLog
=
{
"sistema.log"
,
'E'
}
;
Book
archivoResultados
=
{
"resultados.txt"
,
'E'
}
;
Book
archivoExportacion
=
{
"export/datos.csv"
,
'E'
}
;
Book
archivoPuntajes
=
{
"puntajes.dat"
,
'A'
}
;
Book
archivoInventario
=
{
"inventario.sav"
,
'A'
}
;
Book
archivoEspecial
=
{
"archivo con espacios.txt"
,
'L'
}
;
Book
archivoEspecial2
=
{
"datos_especiales-2023.dat"
,
'E'
}
;
Book
archivoRutaRelativa
=
{
"../datos/config.ini"
,
'L'
}
;
Book
archivoRutaAbsoluta
=
{
"C:/Notch/Engine/data.bin"
,
'E'
}
;
Book
archivoTexto
=
{
"readme.txt"
,
'L'
}
;
Book
archivoImagen
=
{
"textura.png"
,
'L'
}
;
Book
archivoJSON
=
{
"settings.json"
,
'A'
}
;
Book
archivoXML
=
{
"estructura.xml"
,
'A'
}
;
Book
conBarras
=
{
"dir/subdir/archivo.ext"
,
'L'
}
;
Book
conPuntos
=
{
"../../archivo.ext"
,
'E'
}
;
Book
espaciado1
=
{
"compacto.txt"
,
'L'
}
;
Book
espaciado2
=
{
"espacios.txt"
,
'E'
}
;
Book
comentado
=
{
"log.txt"
,
'L'
}
;
SpawnPoint
PolloCrudo
unlock
(
archivoLog
)
;
forge
(
archivoLog
,
"Entrada de log: Inicio de programa"
)
;
lock
(
archivoLog
)
;
Book
nuevoArchivo
=
make
(
{
"nuevo.txt"
,
'E'
}
)
;
unlock
(
archivoConfiguracion
)
;
Spider
contenido
=
gather
(
archivoConfiguracion
)
;
lock
(
archivoConfiguracion
)
;
expand
(
archivoLog
,
archivoResultados
)
;
Book
{
"sinVariable.txt"
,
'A'
}
;
Book
arch1
=
{
"uno.txt"
,
'L'
}
;
Book
arch2
=
{
"dos.txt"
,
'E'
}
;
Book
conComentarioMedio
=
{
"comentado.txt"
,
'A'
}
;
PolloAsado
worldSave
WorldName
PruebaOpAritmeticos
:
Inventory
Stack
a
=
10
;
Stack
b
=
3
;
Stack
c
;
Stack
resultado
;
SpawnPoint
PolloCrudo
c
=
a
+
b
;
dropperSpider
(
"Suma: "
bind
c
)
;
c
=
a
-
b
;
dropperSpider
(
"Resta: "
bind
c
)
;
c
=
a
*
b
;
dropperSpider
(
"Multiplicación: "
bind
c
)
;
c
=
a
b
;
dropperSpider
(
"División entera: "
bind
c
)
;
c
=
a
%
b
;
dropperSpider
(
"Módulo: "
bind
c
)
;
resultado
=
a
+
b
*
c
;
dropperSpider
(
"a + b * c = "
bind
resultado
)
;
resultado
=
(
a
+
b
)
*
c
;
dropperSpider
(
"(a + b) * c = "
bind
resultado
)
;
resultado
=
a
+
b
+
c
;
dropperSpider
(
"a + b + c = "
bind
resultado
)
;
resultado
=
a
*
b
c
+
a
-
b
;
dropperSpider
(
"a * b // c + a - b = "
bind
resultado
)
;
resultado
=
-
a
;
dropperSpider
(
"-a = "
bind
resultado
)
;
resultado
=
5
+
3
;
dropperSpider
(
"5 + 3 = "
bind
resultado
)
;
resultado
=
-
(
a
+
b
)
;
dropperSpider
(
"-(a + b) = "
bind
resultado
)
;
resultado
=
a
+
b
;
resultado
=
a
-
b
;
resultado
=
a
*
b
;
resultado
=
a
b
;
resultado
=
a
%
b
;
resultado
=
a
+
b
;
resultado
=
a
-
b
;
resultado
=
a
*
b
;
resultado
=
a
b
;
resultado
=
a
%
b
;
resultado
=
a
+
b
;
resultado
=
a
*
b
;
resultado
=
(
(
(
(
a
+
b
)
*
c
)
2
)
%
10
)
;
soulsand
a
;
resultado
=
a
+
b
;
magma
b
;
resultado
=
a
-
b
;
PolloAsado
worldSave
WorldName
PruebaOpFlotantes
:
Inventory
Ghast
x
=
10.5
;
Ghast
y
=
3.25
;
Ghast
z
;
Ghast
resultado
;
SpawnPoint
PolloCrudo
z
=
x
:
+
y
;
dropperSpider
(
"Suma flotante: "
bind
z
)
;
z
=
x
:
-
y
;
dropperSpider
(
"Resta flotante: "
bind
z
)
;
z
=
x
:
*
y
;
dropperSpider
(
"Multiplicación flotante: "
bind
z
)
;
z
=
x
:
y
;
dropperSpider
(
"División flotante: "
bind
z
)
;
z
=
x
:
%
y
;
dropperSpider
(
"Módulo flotante: "
bind
z
)
;
resultado
=
x
:
+
y
:
*
z
;
dropperSpider
(
"x :+ y :* z = "
bind
resultado
)
;
resultado
=
(
x
:
+
y
)
:
*
z
;
dropperSpider
(
"(x :+ y) :* z = "
bind
resultado
)
;
resultado
=
x
:
+
y
:
+
z
;
dropperSpider
(
"x :+ y :+ z = "
bind
resultado
)
;
resultado
=
x
:
*
y
:
z
:
+
x
:
-
y
;
dropperSpider
(
"x :* y :// z :+ x :- y = "
bind
resultado
)
;
resultado
=
-
x
;
dropperSpider
(
"-x = "
bind
resultado
)
;
resultado
=
5.5
:
+
3.2
;
dropperSpider
(
"5.5 :+ 3.2 = "
bind
resultado
)
;
resultado
=
-
(
x
:
+
y
)
;
dropperSpider
(
"-(x :+ y) = "
bind
resultado
)
;
resultado
=
x
:
+
y
;
resultado
=
x
:
-
y
;
resultado
=
x
:
*
y
;
resultado
=
x
:
y
;
resultado
=
x
:
%
y
;
resultado
=
x
:
+
y
;
resultado
=
x
:
-
y
;
resultado
=
x
:
*
y
;
resultado
=
x
:
y
;
resultado
=
x
:
%
y
;
resultado
=
x
:
+
y
;
resultado
=
x
:
*
y
;
resultado
=
(
(
(
(
x
:
+
y
)
:
*
z
)
:
2.0
)
:
%
10.0
)
;
Ghast
mezcla1
=
x
:
+
5
;
Ghast
mezcla2
=
3.5
:
*
y
;
Ghast
mezcla3
=
x
:
+
(
y
:
*
2.0
)
:
1.5
;
Spider
texto
=
"Notch:Engine"
;
Stack
entero
=
(
x
:
+
y
)
>
>
Stack
;
PolloAsado
worldSave
WorldName
PruebaOpComparacion
:
Inventory
Stack
a
=
10
;
Stack
b
=
5
;
Torch
resultado
;
Ghast
x
=
3.5
;
Ghast
y
=
2.75
;
Spider
cadena1
=
"abc"
;
Spider
cadena2
=
"def"
;
Rune
char1
=
'A'
;
Rune
char2
=
'B'
;
Torch
bool1
=
On
;
Torch
bool2
=
Off
;
SpawnPoint
PolloCrudo
resultado
=
a
<
b
;
dropperSpider
(
"a < b: "
bind
resultado
)
;
resultado
=
x
<
y
;
dropperSpider
(
"x < y: "
bind
resultado
)
;
resultado
=
cadena1
<
cadena2
;
dropperSpider
(
"cadena1 < cadena2: "
bind
resultado
)
;
resultado
=
char1
<
char2
;
dropperSpider
(
"char1 < char2: "
bind
resultado
)
;
resultado
=
a
>
b
;
dropperSpider
(
"a > b: "
bind
resultado
)
;
resultado
=
x
>
y
;
dropperSpider
(
"x > y: "
bind
resultado
)
;
resultado
=
a
<=
b
;
dropperSpider
(
"a <= b: "
bind
resultado
)
;
resultado
=
x
<=
y
;
dropperSpider
(
"x <= y: "
bind
resultado
)
;
resultado
=
a
>=
b
;
dropperSpider
(
"a >= b: "
bind
resultado
)
;
resultado
=
x
>=
y
;
dropperSpider
(
"x >= y: "
bind
resultado
)
;
resultado
=
a
is
b
;
dropperSpider
(
"a is b: "
bind
resultado
)
;
resultado
=
x
is
y
;
dropperSpider
(
"x is y: "
bind
resultado
)
;
resultado
=
cadena1
is
cadena2
;
dropperSpider
(
"cadena1 is cadena2: "
bind
resultado
)
;
resultado
=
bool1
is
bool2
;
dropperSpider
(
"bool1 is bool2: "
bind
resultado
)
;
resultado
=
a
isNot
b
;
dropperSpider
(
"a isNot b: "
bind
resultado
)
;
resultado
=
x
isNot
y
;
dropperSpider
(
"x isNot y: "
bind
resultado
)
;
resultado
=
cadena1
isNot
cadena2
;
dropperSpider
(
"cadena1 isNot cadena2: "
bind
resultado
)
;
resultado
=
bool1
isNot
bool2
;
dropperSpider
(
"bool1 isNot bool2: "
bind
resultado
)
;
resultado
=
a
<
b
;
resultado
=
a
>
b
;
resultado
=
a
<=
b
;
resultado
=
a
>=
b
;
resultado
=
aisb
;
resultado
=
a
is
b
;
resultado
=
aisNotb
;
resultado
=
a
isNot
b
;
resultado
=
a
<
b
;
resultado
=
a
>
b
;
resultado
=
a
<=
b
;
resultado
=
a
>=
b
;
resultado
=
a
is
b
;
resultado
=
a
isNot
b
;
target
a
<
b
craft
hit
PolloCrudo
dropperSpider
(
"a es menor que b"
)
;
PolloAsado
repeater
x
>
y
craft
PolloCrudo
dropperSpider
(
"x es mayor que y"
)
;
PolloAsado
resultado
=
(
a
+
b
)
>
(
x
:
+
y
)
;
resultado
=
a
*
2
<=
b
*
3
;
resultado
=
(
a
2
)
is
(
b
1
)
;
resultado
=
bind
(
cadena1
,
cadena2
)
isNot
"abcdef"
;
Spider
islandia
=
"país"
;
Stack
isNotacion
=
42
;
PolloAsado
worldSave
WorldName
PruebaOpAsignacion
:
Inventory
Stack
contador
=
10
;
Stack
acumulador
=
0
;
Ghast
decimal
=
5.5
;
Spider
texto
=
"Notch"
;
Shelf
[
5
]
Stack
arreglo
;
Entity
Punto
PolloCrudo
Stack
x
;
Stack
y
;
PolloAsado
;
Entity
Punto
punto
;
SpawnPoint
PolloCrudo
contador
=
5
;
dropperSpider
(
"Asignación simple: "
bind
contador
)
;
decimal
=
3.14
;
texto
=
"Engine"
;
contador
+
=
3
;
dropperSpider
(
"Asignación con suma: "
bind
contador
)
;
acumulador
=
0
;
acumulador
+
=
contador
;
acumulador
+
=
2
;
dropperSpider
(
"Acumulador después de += : "
bind
acumulador
)
;
contador
-
=
2
;
dropperSpider
(
"Asignación con resta: "
bind
contador
)
;
acumulador
=
20
;
acumulador
-
=
5
;
acumulador
-
=
contador
;
dropperSpider
(
"Acumulador después de -= : "
bind
acumulador
)
;
contador
*
=
3
;
dropperSpider
(
"Asignación con multiplicación: "
bind
contador
)
;
acumulador
=
2
;
acumulador
*
=
contador
;
dropperSpider
(
"Acumulador después de *= : "
bind
acumulador
)
;
contador
=
2
;
dropperSpider
(
"Asignación con división: "
bind
contador
)
;
acumulador
=
50
;
acumulador
=
5
;
dropperSpider
(
"Acumulador después de /= : "
bind
acumulador
)
;
contador
%
=
3
;
dropperSpider
(
"Asignación con módulo: "
bind
contador
)
;
acumulador
=
17
;
acumulador
%
=
5
;
dropperSpider
(
"Acumulador después de %= : "
bind
acumulador
)
;
arreglo
[
0
]
=
10
;
arreglo
[
1
]
=
20
;
arreglo
[
2
]
=
30
;
arreglo
[
0
]
+
=
5
;
dropperSpider
(
"arreglo[0] después de += : "
bind
arreglo
[
0
]
)
;
arreglo
[
1
]
-
=
5
;
dropperSpider
(
"arreglo[1] después de -= : "
bind
arreglo
[
1
]
)
;
arreglo
[
2
]
*
=
2
;
dropperSpider
(
"arreglo[2] después de *= : "
bind
arreglo
[
2
]
)
;
punto
@
x
=
10
;
punto
@
y
=
20
;
punto
@
x
+
=
5
;
dropperSpider
(
"punto@x después de += : "
bind
punto
@
x
)
;
punto
@
y
-
=
8
;
dropperSpider
(
"punto@y después de -= : "
bind
punto
@
y
)
;
contador
=
5
;
contador
+
=
3
;
contador
-
=
2
;
contador
*
=
4
;
contador
=
2
;
contador
%
=
3
;
contador
=
5
;
contador
+
=
3
;
contador
-
=
2
;
contador
*
=
4
;
contador
=
2
;
contador
%
=
3
;
contador
=
10
;
contador
+
=
5
;
Stack
a
=
1
,
b
=
2
,
c
=
3
;
contador
=
(
a
+
b
)
*
c
;
contador
+
=
a
*
b
;
contador
-
=
a
+
b
;
contador
*
=
(
a
*
2
)
+
(
b
*
3
)
;
contador
=
a
+
1
;
contador
%
=
b
*
2
;
a
=
10
;
b
=
20
;
c
=
30
;
Spider
igual_texto
=
"Este texto tiene un signo = dentro"
;
Spider
mas_texto
=
"Este texto tiene un signo + dentro"
;
Spider
menos_texto
=
"Este texto tiene un signo - dentro"
;
Spider
por_texto
=
"Este texto tiene un signo * dentro"
;
Spider
div_texto
=
"Este texto tiene un signo / dentro"
;
Spider
mod_texto
=
"Este texto tiene un signo % dentro"
;
PolloAsado
worldSave
WorldName
PruebaOpAcceso
:
Inventory
Shelf
[
5
]
Stack
numeros
;
Shelf
[
3
]
Shelf
[
3
]
matriz
;
Shelf
[
2
]
Shelf
[
2
]
Shelf
[
2
]
cubo
;
Spider
texto
=
"Notch Engine"
;
Entity
Punto
PolloCrudo
Stack
x
;
Stack
y
;
Stack
z
;
PolloAsado
;
Entity
Punto
punto
;
Entity
Persona
PolloCrudo
Spider
nombre
;
Stack
edad
;
Torch
activo
;
Shelf
[
3
]
Stack
notas
;
PolloAsado
;
Entity
Persona
estudiante
;
Shelf
[
3
]
Entity
Punto
puntos
;
Entity
Contenedor
PolloCrudo
Shelf
[
5
]
Stack
valores
;
Spider
etiqueta
;
PolloAsado
;
Entity
Contenedor
caja
;
SpawnPoint
PolloCrudo
numeros
[
0
]
=
10
;
numeros
[
1
]
=
20
;
numeros
[
2
]
=
30
;
Stack
valor
=
numeros
[
0
]
;
dropperSpider
(
"Valor en numeros[0]: "
bind
valor
)
;
Stack
indice
=
2
;
valor
=
numeros
[
indice
]
;
dropperSpider
(
"Valor en numeros[indice]: "
bind
valor
)
;
valor
=
numeros
[
1
+
1
]
;
dropperSpider
(
"Valor en numeros[1 + 1]: "
bind
valor
)
;
matriz
[
0
]
[
0
]
=
11
;
matriz
[
0
]
[
1
]
=
12
;
matriz
[
1
]
[
0
]
=
21
;
matriz
[
1
]
[
1
]
=
22
;
valor
=
matriz
[
1
]
[
1
]
;
dropperSpider
(
"Valor en matriz[1][1]: "
bind
valor
)
;
valor
=
matriz
[
indice
-
1
]
[
indice
-
1
]
;
dropperSpider
(
"Valor en matriz[indice - 1][indice - 1]: "
bind
valor
)
;
cubo
[
0
]
[
0
]
[
0
]
=
111
;
cubo
[
1
]
[
1
]
[
1
]
=
222
;
valor
=
cubo
[
1
]
[
1
]
[
1
]
;
dropperSpider
(
"Valor en cubo[1][1][1]: "
bind
valor
)
;
Rune
caracter
=
texto
[
0
]
;
dropperSpider
(
"Carácter en texto[0]: "
bind
caracter
)
;
caracter
=
texto
[
6
]
;
dropperSpider
(
"Carácter en texto[6]: "
bind
caracter
)
;
caracter
=
texto
[
indice
*
2
]
;
dropperSpider
(
"Carácter en texto[indice * 2]: "
bind
caracter
)
;
texto
[
0
]
=
'n'
;
dropperSpider
(
"Texto modificado: "
bind
texto
)
;
punto
@
x
=
10
;
punto
@
y
=
20
;
punto
@
z
=
30
;
valor
=
punto
@
x
;
dropperSpider
(
"Valor en punto@x: "
bind
valor
)
;
punto
@
y
=
punto
@
x
*
2
;
dropperSpider
(
"Valor en punto@y después de asignación: "
bind
punto
@
y
)
;
estudiante
@
nombre
=
"Steve"
;
estudiante
@
edad
=
25
;
estudiante
@
activo
=
On
;
estudiante
@
notas
[
0
]
=
85
;
estudiante
@
notas
[
1
]
=
90
;
estudiante
@
notas
[
2
]
=
95
;
Spider
nombre
=
estudiante
@
nombre
;
dropperSpider
(
"Nombre del estudiante: "
bind
nombre
)
;
Stack
nota
=
estudiante
@
notas
[
1
]
;
dropperSpider
(
"Segunda nota del estudiante: "
bind
nota
)
;
puntos
[
0
]
@
x
=
1
;
puntos
[
0
]
@
y
=
2
;
puntos
[
0
]
@
z
=
3
;
puntos
[
1
]
@
x
=
4
;
puntos
[
1
]
@
y
=
5
;
puntos
[
1
]
@
z
=
6
;
valor
=
puntos
[
1
]
@
y
;
dropperSpider
(
"Valor en puntos[1]@y: "
bind
valor
)
;
caja
@
etiqueta
=
"Items"
;
caja
@
valores
[
0
]
=
100
;
caja
@
valores
[
1
]
=
200
;
valor
=
caja
@
valores
[
1
]
;
dropperSpider
(
"Valor en caja@valores[1]: "
bind
valor
)
;
valor
=
numeros
[
0
]
;
nombre
=
estudiante
@
nombre
;
valor
=
numeros
[
0
]
;
valor
=
matriz
[
1
]
[
1
]
;
nombre
=
estudiante
@
nombre
;
valor
=
cubo
[
0
]
[
matriz
[
0
]
[
0
]
%
3
]
[
numeros
[
0
]
10
]
;
valor
=
numeros
[
0
]
;
nombre
=
estudiante
@
nombre
;
Spider
textoCuadrado
=
"Esto no es un [acceso]"
;
Spider
textoArroba
=
"Email: usuario@dominio.com"
;
PolloAsado
worldSave
WorldName
PruebaOpEspeciales
:
Bedrock
Obsidian
Stack
MAX_SIZE
1024
;
Inventory
Stack
entero
=
42
;
Ghast
flotante
=
3.14159
;
Spider
texto
=
"Notch Engine"
;
Rune
caracter
=
'A'
;
Torch
booleano
=
On
;
Shelf
[
5
]
Stack
arreglo
;
Chest
conjunto
=
{
:
1
,
2
,
3
:
}
;
Entity
Punto
PolloCrudo
Stack
x
;
Stack
y
;
PolloAsado
;
Entity
Punto
punto
;
SpawnPoint
PolloCrudo
Stack
tamanoStack
=
chunk
Stack
;
Stack
tamanoGhast
=
chunk
Ghast
;
Stack
tamanoSpider
=
chunk
Spider
;
Stack
tamanoRune
=
chunk
Rune
;
Stack
tamanoTorch
=
chunk
Torch
;
dropperSpider
(
"Tamaño de Stack en bytes: "
bind
tamanoStack
)
;
dropperSpider
(
"Tamaño de Ghast en bytes: "
bind
tamanoGhast
)
;
dropperSpider
(
"Tamaño de Spider en bytes: "
bind
tamanoSpider
)
;
dropperSpider
(
"Tamaño de Rune en bytes: "
bind
tamanoRune
)
;
dropperSpider
(
"Tamaño de Torch en bytes: "
bind
tamanoTorch
)
;
Stack
tamanoShelf
=
chunk
Shelf
[
5
]
Stack
;
Stack
tamanoChest
=
chunk
Chest
;
Stack
tamanoPunto
=
chunk
Punto
;
dropperSpider
(
"Tamaño de arreglo en bytes: "
bind
tamanoShelf
)
;
dropperSpider
(
"Tamaño de conjunto en bytes: "
bind
tamanoChest
)
;
dropperSpider
(
"Tamaño de Punto en bytes: "
bind
tamanoPunto
)
;
Stack
tamanoVariable
=
chunk
entero
;
Stack
tamanoArreglo
=
chunk
arreglo
;
Stack
tamanoTexto
=
chunk
texto
;
dropperSpider
(
"Tamaño de variable entero en bytes: "
bind
tamanoVariable
)
;
dropperSpider
(
"Tamaño de variable arreglo en bytes: "
bind
tamanoArreglo
)
;
dropperSpider
(
"Tamaño de variable texto en bytes: "
bind
tamanoTexto
)
;
Stack
tamanoExpresion
=
chunk
(
entero
*
2
+
10
)
;
dropperSpider
(
"Tamaño de expresión en bytes: "
bind
tamanoExpresion
)
;
Stack
enteroDeFlotante
=
flotante
>
>
Stack
;
dropperSpider
(
"Flotante convertido a entero: "
bind
enteroDeFlotante
)
;
Torch
booleanoDeEntero
=
entero
>
>
Torch
;
dropperSpider
(
"Entero convertido a booleano: "
bind
booleanoDeEntero
)
;
Rune
caracterDeTexto
=
texto
>
>
Rune
;
dropperSpider
(
"Primer carácter del texto: "
bind
caracterDeTexto
)
;
Stack
resultadoEntero
=
(
flotante
:
+
2.5
)
>
>
Stack
;
dropperSpider
(
"Suma flotante convertida a entero: "
bind
resultadoEntero
)
;
Stack
tam1
=
chunkStack
;
Stack
tam2
=
chunk
Stack
;
Stack
tam3
=
chunk
(
Stack
)
;
Stack
ent1
=
flotante
>
>
Stack
;
Stack
ent2
=
flotante
>
>
Stack
;
Stack
tam4
=
chunk
Stack
;
Stack
ent3
=
flotante
>
>
Stack
;
Stack
tam5
=
chunk
Stack
;
Stack
ent4
=
flotante
>
>
Stack
;
Stack
tamCombinado
=
chunk
(
flotante
>
>
Stack
)
;
Spider
textoMayor
=
"Esto no es una coherción >>"
;
Spider
textoChunk
=
"La palabra chunk no es un operador aquí"
;
Stack
resultado
=
(
flotante
:
*
2.0
>
>
Stack
)
+
(
entero
*
3
)
;
target
(
flotante
>
>
Stack
)
>
3
craft
hit
PolloCrudo
dropperSpider
(
"La parte entera de flotante es mayor que 3"
)
;
PolloAsado
PolloAsado
worldSave
WorldName
PruebaComLinea
:
Bedrock
Obsidian
Stack
MAX_LEVEL
100
;
Obsidian
Spider
VERSION
"1.0"
;
Inventory
Stack
contador
=
0
;
Spider
texto
=
"Notch Engine"
;
Rune
inicial
;
Stack
a
=
10
,
b
=
20
;
Recipe
Spell
calcular
(
Stack
::
a
,
b
)
->
Stack
;
CraftingTable
Spell
calcular
(
Stack
::
a
,
b
)
->
Stack
PolloCrudo
Stack
resultado
=
a
+
b
;
respawn
resultado
;
PolloAsado
Ritual
mostrarMensaje
(
Spider
::
mensaje
)
PolloCrudo
dropperSpider
(
mensaje
)
;
PolloAsado
SpawnPoint
PolloCrudo
contador
=
5
;
target
contador
>
0
craft
hit
PolloCrudo
dropperSpider
(
"Contador positivo"
)
;
PolloAsado
Stack
resultado
=
contador
+
10
;
Stack
suma
=
calcular
(
5
,
10
)
;
;
PolloAsado
worldSave
WorldName
PruebaComBloque
:
Bedrock
Obsidian
Stack
MAX_LEVEL
100
;
Obsidian
Spider
VERSION
"1.0"
;
Inventory
Stack
contador
=
0
;
Spider
texto
=
"Notch Engine"
;
Rune
inicial
;
Stack
a
=
10
,
b
=
20
;
Recipe
Spell
calcular
(
Stack
::
a
,
b
)
->
Stack
;
CraftingTable
Spell
calcular
(
Stack
::
a
,
b
)
->
Stack
PolloCrudo
Stack
resultado
=
a
+
b
;
respawn
resultado
;
PolloAsado
Ritual
mostrarMensaje
(
Spider
::
mensaje
)
PolloCrudo
dropperSpider
(
mensaje
)
;
PolloAsado
SpawnPoint
PolloCrudo
contador
=
5
+
10
;
target
contador
>
0
craft
hit
PolloCrudo
dropperSpider
(
"Contador positivo"
)
;
PolloAsado
dentro
pero
sin
cerrar
aún
*
secuencias
*
PolloAsado
worldSave
WorldName
PruebaComentarios
:
Inventory
Stack
contador
=
10
;
Spider
texto
=
"Comentario /* falso */ dentro de un string"
;
Rune
caracter
=
'*'
;
SpawnPoint
PolloCrudo
dropperSpider
(
"Los comentarios son importantes"
)
;
PolloAsado
worldSave
WorldName
PruebaIdentificadoresSimples
:
Bedrock
Obsidian
Stack
MAX
100
;
Obsidian
Spider
TITULO
"Notch Engine"
;
Inventory
Stack
a
;
Stack
contador
;
Stack
nivel
;
Stack
x
;
Stack
y
;
Stack
z
;
Stack
posicion
;
Stack
altura
;
Stack
ancho
;
Spider
nombre
;
Spider
texto
;
Spider
mensaje
;
Spider
saludo
;
Torch
activo
;
Torch
visible
;
Torch
terminado
;
Rune
inicial
;
Rune
caracter
;
Rune
simbolo
;
Ghast
pi
;
Ghast
temperatura
;
Ghast
velocidad
;
Stack
Contador
;
Spider
Nombre
;
Torch
Activo
;
Stack
i
;
Stack
j
;
Stack
k
;
Rune
c
;
Spider
s
;
Torch
b
;
Ghast
f
;
CraftingTable
Spell
suma
(
Stack
::
a
,
b
)
->
Stack
PolloCrudo
Stack
resultado
;
resultado
=
a
+
b
;
respawn
resultado
;
PolloAsado
Ritual
imprimir
(
Spider
::
mensaje
)
PolloCrudo
dropperSpider
(
mensaje
)
;
PolloAsado
SpawnPoint
PolloCrudo
Stack
valor
;
Stack
resultado
;
Spider
mensaje
;
valor
=
10
;
mensaje
=
"Hola"
;
resultado
=
valor
+
5
;
valor
=
suma
(
valor
,
20
)
;
ender_pearl
imprimir
(
mensaje
)
;
PolloAsado
worldSave
WorldName
PruebaIdentificadoresComplejos
:
Bedrock
Obsidian
Stack
MAX_LEVEL
100
;
Obsidian
Stack
MIN_LEVEL
1
;
Obsidian
Spider
GAME_TITLE
"Notch Engine"
;
Obsidian
Spider
VERSION_1_0
"v1.0"
;
Inventory
Stack
player_level
;
Stack
enemy_count
;
Stack
max_health
;
Stack
min_damage
;
Stack
current_position_x
;
Stack
counter1
;
Stack
item2
;
Stack
level3d
;
Stack
position2d
;
Stack
player1_health
;
Stack
item_1
;
Stack
player_2_score
;
Stack
enemy_level_3
;
Stack
position_x_1
;
Stack
inventory_slot_5
;
Stack
_temp
;
Stack
_internal_counter
;
Stack
_system_value
;
Stack
_player_data
;
Stack
very_long_variable_name_with_many_words
;
Spider
extremely_long_message_text_that_describes_something_in_detail
;
Torch
is_player_currently_in_creative_mode_with_flight_enabled
;
Stack
player5_current_health_max_100
;
Stack
enemy_3d_position_coordinate_x_12
;
Rune
player_initial_1
;
Spider
user_5_name
;
CraftingTable
Spell
calculate_total_damage
(
Stack
::
base_damage
,
critical_multiplier
;
Torch
::
is_headshot
)
->
Stack
PolloCrudo
Stack
total_damage
;
total_damage
=
base_damage
*
critical_multiplier
;
target
is_headshot
craft
hit
PolloCrudo
total_damage
=
total_damage
*
2
;
PolloAsado
respawn
total_damage
;
PolloAsado
Ritual
display_player_stats
(
Spider
::
player_name
;
Stack
level_1
,
health_points_100
)
PolloCrudo
dropperSpider
(
"Player: "
bind
player_name
)
;
dropperSpider
(
"Level: "
bind
level_1
)
;
dropperSpider
(
"Health: "
bind
health_points_100
)
;
PolloAsado
SpawnPoint
PolloCrudo
Stack
player1_health
=
100
;
Stack
enemy_count_5
=
10
;
Spider
main_player_name
=
"Steve_123"
;
player1_health
=
player1_health
-
20
;
enemy_count_5
=
calculate_total_damage
(
10
,
2
,
On
)
;
ender_pearl
display_player_stats
(
main_player_name
,
5
,
player1_health
)
;
Stack
___special_value
=
42
;
dropperStack
(
___special_value
)
;
PolloAsado
worldSave
WorldName
PruebaIdentificadoresSimilares
:
Bedrock
Obsidian
Stack
WorldNameTest
100
;
Obsidian
Spider
BedrockType
"Hard Stone"
;
Obsidian
Torch
InventoryFull
On
;
Inventory
Stack
worldname
;
Stack
WorldName2
;
Stack
bedrock
;
Stack
Bedrock_Type
;
Stack
inventory
;
Stack
InventorySlot
;
Stack
recipe
;
Stack
RecipeBook
;
Stack
craftingtable
;
Stack
CraftingTable2
;
Stack
spawnpoint
;
Stack
SpawnPoint_Main
;
Stack
stack
;
Spider
spider
;
Torch
torch
;
Rune
rune
;
Ghast
ghast
;
Chest
chest
;
Book
book
;
Stack
pollocrudo
;
Stack
PolloAsado
;
Stack
polloAsadoExtra
;
Stack
repeater
;
Stack
target
;
Stack
hit
;
Stack
miss
;
Stack
craft
;
Stack
jukebox
;
Stack
disc
;
Stack
silence
;
Stack
spawner
;
Stack
exhausted
;
Stack
walk
;
Stack
set
;
Stack
to
;
Stack
step
;
Stack
wither
;
Stack
creeper
;
Stack
enderPearl
;
Stack
enderpearlitem
;
Stack
ragequit
;
Stack
spell
;
Stack
Spell_Cast
;
Stack
ritual
;
Stack
RitualCeremony
;
Stack
respawn
;
Stack
respawnPoint
;
Stack
ender_pearl
;
Stack
enderpearlTeleport
;
Stack
soulsand
;
Stack
SoulSandBlock
;
Stack
magma
;
Stack
MagmaBlock
;
Stack
and
;
Stack
andOperator
;
Stack
or
;
Stack
orGate
;
Stack
not
;
Stack
notOperator
;
Stack
xor
;
Stack
xorCalculation
;
Stack
is
;
Stack
isNot
;
Stack
isEqual
;
Torch
on
;
Torch
onSwitch
;
Torch
off
;
Torch
offState
;
Stack
hopper
;
Stack
hopperMinecart
;
Stack
dropper
;
Stack
dropperFunction
;
CraftingTable
Spell
worldNameGenerator
(
)
->
Spider
PolloCrudo
Spider
spawnpoint
=
"DefaultSpawn"
;
Stack
craft
=
10
;
Spider
ritual
=
"Magic"
;
respawn
"Generated"
;
PolloAsado
Ritual
craftingTableMaker
(
Spider
::
recipe
;
Stack
inventory
)
PolloCrudo
Stack
spell
=
20
;
Stack
worldname
=
30
;
Torch
on
=
Off
;
dropperSpider
(
"Crafting table ready"
)
;
PolloAsado
SpawnPoint
PolloCrudo
Stack
worldname
=
1
;
Stack
bedrock
=
2
;
Stack
inventory
=
3
;
Stack
recipe
=
4
;
Stack
craftingtable
=
5
;
Stack
spawnpoint
=
6
;
worldname
=
worldname
+
bedrock
;
inventory
=
craftingtable
*
spawnpoint
;
target
worldname
>
recipe
craft
hit
PolloCrudo
Spider
spell
=
"Magic"
;
dropperSpider
(
spell
)
;
PolloAsado
Spider
generatedName
=
worldNameGenerator
(
)
;
ender_pearl
craftingTableMaker
(
"New Recipe"
,
inventory
)
;
PolloAsado
worldSave
WorldName
PruebaStringsLargos
:
Inventory
Spider
string_normal
=
"Este es un string normal"
;
Spider
string_largo
=
"Este es un string extremadamente largo para probar cómo maneja el analizador léxico los tokens de gran tamaño. El propósito es verificar si el buffer del analizador puede manejar correctamente cadenas que exceden el tamaño típico. En Minecraft, los jugadores pueden construir estructuras enormes y elaboradas, similar a cómo este string se extiende más allá de los límites normales. Las cadenas largas son útiles para almacenar textos extensos como descripciones, historias, o mensajes de diálogo en juegos. Este string sigue creciendo para asegurar que supere los límites habituales de procesamiento del analizador léxico."
;
Spider
string_muy_largo
=
"Este string es aún más largo que el anterior, llegando a aproximadamente mil caracteres para poner realmente a prueba los límites del analizador léxico. En el desarrollo de compiladores, es importante verificar cómo responde el sistema ante casos extremos. Los buffers mal dimensionados podrían causar desbordamientos o truncamientos inesperados. En el mundo de Minecraft, esto sería comparable a construir una megaestructura que se extiende hasta los límites permitidos del mundo. Es crucial que el compilador maneje correctamente estos casos límite, ya que en aplicaciones reales, los usuarios pueden introducir textos extremadamente largos, como documentación, logs detallados, o incluso código generado automáticamente. Este string continúa creciendo, añadiendo más y más caracteres para asegurar que pruebe adecuadamente la capacidad del buffer del analizador léxico. Una implementación robusta debería ser capaz de manejar este token sin problemas, reconociéndolo correctamente como un único string literal, sin importar su longitud. El tamaño máximo debería estar limitado únicamente por la memoria disponible en el sistema, no por limitaciones arbitrarias en el diseño del analizador léxico. Este string sigue y sigue, añadiendo más palabras y caracteres, para garantizar que realmente ponga a prueba los límites del analizador."
;
Spider
string_con_escapes
=
"Este string incluye secuencias de escape como: \n nueva línea, \t tabulación, \" comillas dobles, \\ barra invertida, y otros caracteres especiales como !@#$%^&*()_+-={}[]|:;<>,.?/~`"
;
Spider
string_multilinea
=
"Línea 1\nLínea 2\nLínea 3\nLínea 4\nLínea 5\nLínea 6\nLínea 7\nLínea 8\nLínea 9\nLínea 10\nLínea 11\nLínea 12\nLínea 13\nLínea 14\nLínea 15\nLínea 16\nLínea 17\nLínea 18\nLínea 19\nLínea 20"
;
Spider
string_simbolos
=
"Este string contiene símbolos que son tokens en Notch Engine: +, -, *, //, %, :+, :-, :*, :%, ://, @, [], {}, {: :}, {/ /}, >>. También incluye palabras reservadas como WorldName, Inventory, SpawnPoint, craft, respawn, soulsand, magma, etc."
;
Spider
string_extremo
=
"Este string es extremadamente largo AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA, superando los dos mil caracteres para realmente llevar al límite la capacidad del analizador léxico. En el desarrollo de compiladores e intérpretes, es fundamental probar cómo maneja el sistema casos extremos como este. Cualquier limitación no prevista en el diseño podría manifestarse al procesar tokens de este tamaño. En Minecraft, esto sería equivalente a construir una estructura colosal que se extiende por miles de bloques en todas direcciones, poniendo a prueba los límites del motor del juego. Los analizadores léxicos deben estar preparados para manejar tokens de cualquier longitud razonable, ya que en aplicaciones del mundo real, los usuarios pueden necesitar procesar textos extremadamente largos. Ejemplos incluyen el procesamiento de documentos completos, archivos de configuración extensos, o incluso código generado automáticamente que puede extenderse por miles de líneas. Este string sigue creciendo, añadiendo más y más palabras y caracteres, para asegurar que realmente ponga a prueba los límites del buffer del analizador. Una implementación robusta debería manejar este token sin problemas, reconociéndolo correctamente como un único string literal completo, sin importar su tamaño. El tamaño máximo debería estar limitado únicamente por la memoria disponible en el sistema, no por limitaciones arbitrarias en el diseño del analizador. Este string continúa expandiéndose, añadiendo más contenido para garantizar que supere cualquier buffer de tamaño fijo que pueda haber sido implementado. Es importante también verificar que el rendimiento del analizador no se degrade exponencialmente con tokens muy grandes, lo que podría indicar algoritmos ineficientes. En el contexto de Notch Engine, inspirado en Minecraft, este string sería como un libro dentro del juego con una historia increíblemente detallada que se extiende por múltiples páginas. El analizador léxico debe procesar este token de manera eficiente, reconociéndolo como un único string literal y no fragmentándolo incorrectamente en múltiples tokens. Este string sigue creciendo, agregando más y más caracteres, para asegurar que realmente ponga a prueba los límites del analizador léxico. Continúa expandiéndose, como un mundo de Minecraft que se genera infinitamente, añadiendo más palabras y frases para llegar a una longitud verdaderamente extrema. Este string sigue y sigue y sigue, desafiando las capacidades del analizador, probando su robustez y eficiencia al manejar casos extremos como este."
;
SpawnPoint
PolloCrudo
dropperSpider
(
"Prueba de strings largos completada"
)
;
Stack
longitud
=
#
(
string_largo
)
;
dropperStack
(
longitud
)
;
Spider
subcadena
=
from
string_largo
#
#
0
#
#
50
;
dropperSpider
(
subcadena
)
;
PolloAsado
worldSave
WorldName
PruebaNumeroGrande
:
Bedrock
Obsidian
Stack
NUM_PEQUENO
42
;
Obsidian
Stack
NUM_MEDIANO
12345
;
Obsidian
Stack
NUM_GRANDE
9876543210
;
Obsidian
Stack
NUM_MUY_GRANDE
1234567890123456789
;
Obsidian
Stack
NEG_PEQUENO
-
42
;
Obsidian
Stack
NEG_MEDIANO
-
12345
;
Obsidian
Stack
NEG_GRANDE
-
9876543210
;
Obsidian
Stack
NEG_MUY_GRANDE
-
1234567890123456789
;
Obsidian
Stack
INT_16BIT_MAX
32767
;
Obsidian
Stack
INT_16BIT_MIN
-
32768
;
Obsidian
Stack
INT_32BIT_MAX
2147483647
;
Obsidian
Stack
INT_32BIT_MIN
-
2147483648
;
Obsidian
Stack
INT_64BIT_MAX
9223372036854775807
;
Obsidian
Stack
INT_64BIT_MIN
-
9223372036854775808
;
Obsidian
Stack
NUM_EXTREMO
123456789012345678901234567890
;
Obsidian
Stack
NEG_EXTREMO
-
123456789012345678901234567890
;
Inventory
Stack
num1
=
1234567890
;
Stack
num2
=
9876543210
;
Stack
grande1
=
123456789012345678
;
Stack
grande2
=
987654321098765432
;
Stack
max16
=
32767
;
Stack
min16
=
-
32768
;
Stack
max32
=
2147483647
;
Stack
min32
=
-
2147483648
;
Stack
max64
=
9223372036854775807
;
Stack
min64
=
-
9223372036854775808
;
Stack
extremo
=
123456789012345678901234567890
;
Shelf
[
2147483647
]
Stack
arregloGrande
;
Stack
suma
;
Stack
resta
;
Stack
multiplicacion
;
Stack
division
;
Stack
modulo
;
SpawnPoint
PolloCrudo
suma
=
num1
+
num2
;
resta
=
num2
-
num1
;
multiplicacion
=
num1
*
10
;
division
=
num2
10
;
modulo
=
num2
%
10
;
Stack
resultado1
=
grande1
+
grande2
;
Stack
resultado2
=
extremo
1000
;
Stack
posible_overflow
=
max32
+
1
;
Stack
posible_underflow
=
min32
-
1
;
Stack
producto_grande
=
grande1
*
grande2
;
Stack
division_extrema
=
extremo
3
;
dropperStack
(
suma
)
;
dropperStack
(
resta
)
;
dropperStack
(
multiplicacion
)
;
dropperStack
(
division
)
;
target
producto_grande
>
0
craft
hit
PolloCrudo
dropperSpider
(
"El resultado es positivo"
)
;
PolloAsado
Stack
i
=
0
;
repeater
i
<
5
craft
PolloCrudo
dropperStack
(
i
)
;
dropperStack
(
grande1
)
;
soulsand
i
;
PolloAsado
PolloAsado
worldSave
WorldName
PruebaPrecisionFlotante
:
Bedrock
Obsidian
Ghast
PI_SIMPLE
3.14
;
Obsidian
Ghast
PI_PRECISO
3.14159265358979323846
;
Obsidian
Ghast
EULER
2.71828182845904523536
;
Obsidian
Ghast
RAIZ_DOS
1.41421356237309504880
;
Obsidian
Ghast
PHI
1.61803398874989484820
;
Obsidian
Ghast
SPEED_OF_LIGHT
2.99792458
e8
;
Obsidian
Ghast
PLANCK_CONSTANT
6.62607015
e
-
34
;
Obsidian
Ghast
AVOGADRO
6.02214076
e23
;
Obsidian
Ghast
EXTREMO_PEQUENO
0.0000000000000000000000001
;
Obsidian
Ghast
EXTREMO_GRANDE
123456789012345678901234.5678901234567890
;
Obsidian
Ghast
NEG_PI
-
3.14159265358979
;
Obsidian
Ghast
NEG_EXTREMO
-
0.0000000000000000000000001
;
Obsidian
Ghast
CERO_DECIMAL
0.0
;
Obsidian
Ghast
SOLO_ENTERO
42.0
;
Obsidian
Ghast
SOLO_DECIMAL
0.42
;
Obsidian
Ghast
PUNTO_INICIAL
.
5
;
Inventory
Ghast
normal
=
3.14
;
Ghast
preciso
=
3.141592653589793
;
Ghast
pequeno
=
0.000000000123
;
Ghast
grande
=
1234567890.123456789
;
Ghast
punto_inicial
=
.
25
;
Ghast
sin_decimal
=
42
.
;
Ghast
cientifico1
=
1.23
e5
;
Ghast
cientifico2
=
4.56
e
-
7
;
Ghast
cientifico3
=
7.89
e
+
12
;
Ghast
muy_pequeno
=
0.000000000000000000000000000000000001
;
Ghast
muy_grande
=
999999999999999999999999999999999999999.9
;
Ghast
muchos_digitos
=
123456789012345.678901234567890
;
Ghast
neg_normal
=
-
3.14
;
Ghast
neg_preciso
=
-
3.141592653589793
;
Ghast
neg_pequeno
=
-
0.000000000123
;
Ghast
neg_cientifico
=
-
2.998
e8
;
Ghast
resultado1
;
Ghast
resultado2
;
Ghast
resultado3
;
SpawnPoint
PolloCrudo
resultado1
=
normal
:
+
preciso
;
resultado2
=
preciso
:
-
normal
;
resultado3
=
normal
:
*
2.0
;
Ghast
res_extremo1
=
muy_pequeno
:
*
1000000.0
;
Ghast
res_extremo2
=
muy_grande
:
1000000.0
;
Ghast
division1
=
1.0
:
3.0
;
Ghast
division2
=
2.0
:
3.0
;
Ghast
division_extrema
=
1.0
:
9999999999.0
;
Ghast
res_cientifico
=
cientifico1
:
*
cientifico2
;
dropperGhast
(
resultado1
)
;
dropperGhast
(
resultado2
)
;
dropperGhast
(
division1
)
;
dropperGhast
(
division2
)
;
target
division1
:
<
0.34
craft
hit
PolloCrudo
dropperSpider
(
"La división 1/3 es menor que 0.34"
)
;
PolloAsado
Ghast
i
=
0.0
;
repeater
i
:
<
1.0
craft
PolloCrudo
dropperGhast
(
i
)
;
i
=
i
:
+
0.2
;
PolloAsado
PolloAsado
worldSave
WorldName
PruebaComentarioLargo
:
Inventory
Stack
contador
=
0
;
Stack
despues_comentario
=
1
;
Spider
mensaje
=
"Prueba de comentarios largos"
;
SpawnPoint
PolloCrudo
Stack
i
=
0
;
repeater
i
<
5
craft
PolloCrudo
soulsand
i
;
dropperSpider
(
mensaje
bind
" - iteración "
bind
i
)
;
PolloAsado
dropperSpider
(
"Prueba de comentarios largos completada"
)
;
PolloAsado
worldSave
WorldName
PruebaTokensConsecutivos
:
Bedrock
Obsidian
Stack
MAX_LEVEL5
100
;
Obsidian
Stack
LEVEL_PLUS_SKILL
200
;
Obsidian
Stack
OFFSET_MINUS_5
50
;
Inventory
Stack
a
=
5
;
Stack
b
=
10
;
Stack
c
=
a
+
b
;
Stack
suma
=
5
+
3
;
Stack
resta
=
10
-
7
;
Stack
multiplicacion
=
4
*
3
;
Stack
division
=
20
4
;
Stack
modulo
=
7
%
2
;
Torch
comparacion1
=
5
<
10
;
Torch
comparacion2
=
5
>
3
;
Torch
comparacion3
=
5
<=
5
;
Torch
comparacion4
=
5
>=
5
;
Torch
comparacion5
=
5
is5
;
Torch
comparacion6
=
5
isNot6
;
Stack
expr1
=
5
+
3
*
2
;
Stack
expr2
=
(
5
+
3
)
*
2
;
Stack
expr3
=
5
+
(
3
*
2
)
;
Ghast
f1
=
3.14
;
Ghast
f2
=
f1
:
+
2.5
;
Ghast
f3
=
f1
:
-
1.5
;
Ghast
f4
=
f1
:
*
2.0
;
Ghast
f5
=
f1
:
1.5
;
Shelf
[
5
]
Stack
arreglo
;
Entity
Jugador
PolloCrudo
Spider
nombre
;
Stack
nivel
;
PolloAsado
;
Spider
texto
=
"Hola"
;
Rune
caracter
=
'A'
;
Torch
booleano
=
On
;
Stack
arr
[
0
]
=
10
;
Stack
x
=
1
,
y
=
2
,
z
=
3
;
Stack
normal1
=
10
;
Stack
normal2
=
20
;
Spider
mensaje
=
"Tokens consecutivos"
;
SpawnPoint
PolloCrudo
suma
=
normal1
+
normal2
;
Stack
valor
=
(
normal1
+
5
)
*
(
normal2
-
5
)
;
repeater
suma
>
0
hit
PolloCrudo
suma
=
suma
-
1
;
dropperStack
(
suma
)
;
PolloAsado
target
valor
>=
100
hit
PolloCrudo
dropperSpider
(
"Valor grande"
)
;
PolloAsado
miss
PolloCrudo
dropperSpider
(
"Valor pequeño"
)
;
PolloAsado
dropperSpider
(
mensaje
)
;
dropperStack
(
valor
)
;
normal1
+
=
5
;
normal2
-
=
3
;
dropperStack
(
normal1
)
;
dropperStack
(
normal2
)
;
PolloAsado
worldSave
WorldName
PruebaCaracteresInvalidos
:
Bedrock
Obsidian
Stack
NORMAL
100
;
Obsidian
Stack
ÑANDU
200
;
Obsidian
Stack
AÇÚCAR
300
;
Obsidian
Stack
CAFÉ
400
;
Inventory
Stack
contador
=
0
;
Spider
mensaje
=
"Normal"
;
Stack
año
=
2025
;
Stack
piña
=
10
;
Spider
münzen
=
"Monedas"
;
Spider
öffentlich
=
"Público"
;
Stack
cont
ador
=
5
;
Spider
mens
aje
=
"Texto"
;
Stack
contador
=
10
;
Spider
mensaje
=
"Texto"
;
Stack
monedas
=
100
;
Stack
valor
=
50
;
Spider
texto
=
"Copyright"
;
Spider
texto_unicode
=
"Caracteres especiales: áéíóúñÁÉÍÓÚÑ"
;
Spider
texto_emoji
=
"Emojis: 😀🎮🌍💻"
;
Stack
a
b
;
Stack
c
d
;
Stack
e
f
;
Stack
g
h
;
Stack
valor
otro
;
Stack
valor
contador
=
5
;
Stack
otro
valor
=
10
;
Rune
char_1
=
'€'
;
Rune
char_2
=
'✓'
;
SpawnPoint
PolloCrudo
contador
=
1
;
contador
=
contador
2
;
contador
=
contador
2
;
dropperStack
(
año
)
;
dropperSpider
(
texto_unicode
)
;
contador
=
5
10
;
contador
=
5
10
;
contador
=
5
;
contador
=
contador
+
5
;
dropperSpider
(
"Fin de prueba"
)
;
PolloAsado
worldSave
WorldName
PruebaStringNoTerminado
:
Bedrock
Obsidian
Spider
NOMBRE
"Notch Engine"
;
Obsidian
Spider
VERSION
"1.0"
;
Obsidian
Spider
DESCRIPCION
"Un lenguaje basado en Minecraft;
$$ Constante después del error para verificar recuperación
Obsidian Stack MAX_NIVEL 100;
Inventory
$$ Variables con strings correctamente terminados
Spider normal = "
Este
string
está
bien
";
Spider multilinea = "
Este
string
tiene
nmúltiples
líneas
ny
está
bien
terminado
";
$$ Variable con string no terminado - falta comilla de cierre
Spider incompleto = "
Este
string
no
está
terminado
;
Stack
contador
=
0
;
Spider
confuso
=
"Este string tiene una comilla escapada \" pero no está terminado;
$$ String no terminado al final de una línea
Spider final_linea = "
Este
string
termina
la
línea
pero
no
está
cerrado
Spider
siguiente
=
"Este es un nuevo string"
;
Spider
combinado
=
"String no terminado Stack contador = 5;
$$ String con múltiples líneas pero sin terminar
Spider multilinea_incompleto = "
Este
string
tiene
múltiples
líneas
pero
no
está
terminado
correctamente
;
Spider
comentario_inmediato
=
"String terminado correctamente"
Spider
comentario_error
=
"String no terminado$$ Comentario que no salva el error
$$ String no terminado con comentario de bloque al final
Spider bloque_inmediato = "
String
no
terminado
Spider
consecutivo1
=
"Primer string terminado"
;
Spider
consecutivo2
=
"Segundo string no terminado;
Spider consecutivo3 = "
Tercer
string
terminado
";
SpawnPoint
PolloCrudo
$$ Código normal para contraste
dropperSpider("
Este
mensaje
está
bien
formado
");
$$ Instrucción con string no terminado
dropperSpider("
Este
mensaje
no
está
terminado
;
contador
=
1
;
Spider
resultado
=
normal
bind
"Parte no terminada;
$$ String no terminado en una estructura de control
target normal is "
Comparación
no
terminada
craft
hit
PolloCrudo
dropperSpider
(
"Este código nunca se ejecutará"
)
;
PolloAsado
dropperSpider
(
"String final no terminado
PolloAsado
worldSave
$*
Prueba_Err_ComentarioNoTerminado.ne
Propósito: Verificar detección de comentarios de bloque sin cierre
Fecha: 28/04/2025
*$
WorldName PruebaComentarioNoTerminado:
Bedrock
$$ Constantes normales para contraste
Obsidian Stack MAX_LEVEL 100;
$* Comentario de bloque correctamente cerrado *$
Obsidian Stack MIN_LEVEL 1;
$* Comentario de bloque sin cierre - falta el terminador *$
Obsidian Stack MEDIO_LEVEL 50;
Inventory
$$ Variables normales para contraste
Stack contador = 0;
Spider mensaje = "
Hola
Mundo
";
$*
Comentario de bloque multi-línea correctamente terminado
con varias líneas de texto
*$
Stack variable_normal = 5;
$*
Comentario de bloque multi-línea sin terminar
Este comentario no tiene el terminador correspondiente
y debería generar un error
Torch activo = On; $$ Esta línea no debería ser reconocida como código
Stack valor = 10; $$ Esta línea no debería ser reconocida como código
$$ Variables después del error para verificar recuperación
Stack recuperacion = 20;
$* Otro comentario no terminado
con símbolos que podrían confundir al analizador:
* asterisco suelto
$ signo dólar suelto
*$ esto parece un terminador pero no lo es
$* esto parece un iniciador dentro del comentario
$$ Más código después del segundo comentario no terminado
Torch otra_variable = Off;
$* Comentario aparentemente cerrado, pero con un espacio entre * y $
que debería causar que no se reconozca como terminador * $
$$ Código después del tercer comentario no terminado
Stack tercera_recuperacion = 30;
$*
Este comentario tiene una secuencia que parece un terminador,
pero tiene caracteres en medio: *texto$
Por lo tanto, no está realmente terminado.
$$ Último código para verificar recuperación
Stack ultima_recuperacion = 40;
SpawnPoint
PolloCrudo
$$ Código normal para contraste
dropperSpider("
Inicio
de
programa
");
$* Comentario de bloque sin terminar en el SpawnPoint
Esta sección del código no debería ejecutarse
contador = 5;
dropperStack(contador);
$$ Código después del comentario no terminado
Stack final = 100;
dropperStack(final);
dropperSpider("
Fin
de
programa
");
PolloAsado
$$ Esto debería ser código después del SpawnPoint, que no es válido
$$ pero el analizador léxico igual debería procesarlo como tokens
$*
Comentario final sin terminar
Este es el último elemento del archivo
worldSave
$*
Prueba: 37_Prueba_Err_CaracterNoTerminado
Descripción: Verificar detección de literales de carácter sin cierre
Fecha: 28/04/2025
*$
WorldName PruebaCaracterNoTerminado:
Inventory
$$ Casos de caracteres correctamente formados (para comparación)
Rune letraCorrecta = 'A';
Rune digitoCorrecto = '5';
Rune simboloCorrecto = '@';
Rune escapeCorrecto = '\n';
$$ Casos de caracteres sin cierre (errores léxicos)
Rune errorSimple = 'B; $$ Falta comilla de cierre
Rune errorEscape = '\n; $$ Falta comilla de cierre después de secuencia de escape
$$ Caso con apertura pero sin contenido ni cierre
Rune errorVacio = '; $$ Solo comilla de apertura
$$ Caso con múltiples caracteres (error léxico)
Rune errorMultiple = 'ABC; $$ Múltiples caracteres y falta comilla de cierre
$$ Error dentro de una expresión
Stack valor = 5 + (3 * 'x); $$ Falta comilla de cierre en la expresión
SpawnPoint
PolloCrudo
$$ Este carácter inválido debería ser detectado
Rune pruebaError = 'Z;
dropperSpider("
Este
texto
no
debería
ser
alcanzado
debido
al
error
léxico
");
PolloAsado
worldSave
$*
Prueba: 38_Prueba_Err_SimboloDesconocido
Descripción: Verificar detección de símbolos no reconocidos
Fecha: 28/04/2025
*$
WorldName PruebaSimboloDesconocido:
Bedrock
$$ Símbolos válidos para comparación
Obsidian Stack MAX_VALUE 100;
$$ Símbolo no reconocido: flecha de asignación errónea
Obsidian Stack MIN_VALUE => 0; $$ => no es un símbolo válido
Inventory
$$ Símbolos válidos (para comparación)
Stack contador = 10;
Stack resultado = contador + 5;
$$ Símbolos no reconocidos
Stack valor1 = 5 ^ 2; $$ ^ (potencia) no es un símbolo válido
Stack valor2 = 10 \ 3; $$ \ no es un operador válido
Stack valor3 = valor1 ~ valor2; $$ ~ no es un operador válido
$$ Operadores malformados o incompletos
Stack valor4 = 3 : 4; $$ : solo no es un operador válido (debe ser :+, :-, etc.)
Stack valor5 = 7 / 2; $$ / no es válido (debe ser // para división entera)
$$ Uso de símbolos de otros lenguajes
Stack valor6 = 5 ** 2; $$ ** (potencia en Python) no es válido
Torch condicion = (valor5 == valor6); $$ == no es válido (debe ser 'is')
$$ Símbolo inválido en acceso a estructura
Stack elemento = numeros->0; $$ -> no es válido para acceso (debe ser [])
ResourcePack
$$ Símbolo inválido en declaración de tipo
Anvil Stack ==> Spider; $$ ==> no es un símbolo válido (debe ser ->)
SpawnPoint
PolloCrudo
$$ Operadores inválidos en expresiones
Stack a = 5;
Stack b = 10;
Stack c = a ||| b; $$ ||| no es un operador válido
$$ Símbolos inválidos en estructuras de control
target a < b craft hit
PolloCrudo
dropperSpider("
a
es
menor
que
b
");
PolloAsado
?> $$ ?> no es un símbolo válido
$$ Símbolo inválido como terminador de instrucción
Stack valor = 100#
PolloAsado
worldSave
$*
Prueba: 39_Prueba_Comb_Estructura
Descripción: Verificar estructura básica de un programa completo
Fecha: 28/04/2025
*$
WorldName PruebaEstructuraCompleta:
$$ Sección de constantes
Bedrock
Obsidian Stack MAX_NIVEL 100;
Obsidian Spider VERSION "
1.0
.
0
";
Obsidian Torch DEBUG_MODE Off;
Obsidian Ghast PI 3.14159;
$$ Sección de tipos
ResourcePack
Anvil Ghast -> Stack truncate;
Anvil Stack -> Spider;
$$ Definición de un tipo personalizado
Entity Jugador
PolloCrudo
Spider nombre;
Stack nivel;
Ghast salud;
Torch activo;
PolloAsado;
$$ Sección de variables
Inventory
$$ Variables básicas
Stack contador = 0;
Spider mensaje = "
Bienvenido
a
Notch
Engine
";
Torch juego_activo = On;
Ghast temperatura = 21.5;
Chest letras = {: 'a', 'b', 'c' :};
$$ Variables compuestas
Shelf[5] Stack inventario;
Entity Jugador steve;
$$ Sección de prototipos
Recipe
$$ Prototipo de función
Spell calcularDanio(Stack :: nivel, arma; Ghast ref multiplicador) -> Stack;
$$ Prototipo de procedimiento
Ritual mostrarEstado(Spider :: nombre; Stack nivel, salud);
$$ Sección de implementación de rutinas
CraftingTable
$$ Implementación de función
Spell calcularDanio(Stack :: nivel, arma; Ghast ref multiplicador) -> Stack
PolloCrudo
Stack danio_base = nivel * 2;
target arma is 1 hit
PolloCrudo
danio_base *= 2; $$ Arma mejorada
PolloAsado
multiplicador = 1.5; $$ Modificar parámetro por referencia
respawn danio_base;
PolloAsado
$$ Implementación de procedimiento
Ritual mostrarEstado(Spider :: nombre; Stack nivel, salud)
PolloCrudo
dropperSpider("
==
==
=
Estado
del
Jugador
==
==
=
");
dropperSpider("
Nombre
:
" bind nombre);
dropperSpider("
Nivel
:
" bind nivel);
dropperSpider("
Salud
:
" bind salud);
dropperSpider("
==
==
==
==
==
==
==
==
==
==
==
==
==
==
=
");
PolloAsado
$$ Punto de entrada del programa
SpawnPoint
PolloCrudo
$$ Inicialización
steve@nombre = "
Steve
";
steve@nivel = 1;
steve@salud = 20.0;
steve@activo = On;
$$ Entrada y salida
dropperSpider(mensaje);
dropperSpider("
Ingrese
su
nombre
:
");
Spider nombre_jugador = hopperSpider();
$$ Uso de estructuras de control
target #(nombre_jugador) > 0 hit
PolloCrudo
dropperSpider("
Hola
,
" bind nombre_jugador bind "
");
$$ Uso de funciones y procedimientos
Stack danio = calcularDanio(steve@nivel, 1, 1.0);
dropperSpider("
Tu
daño
base
es
:
" bind danio);
ender_pearl mostrarEstado(steve@nombre, steve@nivel, steve@salud);
$$ Bucle
repeater juego_activo
PolloCrudo
dropperSpider("
Continuar
jugando
(
On
Off
)
");
juego_activo = hopperTorch();
target juego_activo hit
PolloCrudo
soulsand steve@nivel;
dropperSpider("
Nivel
aumentado
a
:
" bind steve@nivel);
PolloAsado
PolloAsado
PolloAsado
miss
PolloCrudo
dropperSpider("
Nombre
no
válido
.
");
PolloAsado
$$ Otros tipos de bucles
Stack i = 0;
spawner
PolloCrudo
soulsand i;
inventario[i] = i * 10;
PolloAsado
exhausted i >= 5;
walk j set 0 to 4
PolloCrudo
dropperSpider("
Inventario
[
" bind j bind "
]
:
" bind inventario[j]);
PolloAsado
PolloAsado
worldSave
$*
Prueba: 40_Prueba_Comb_Declaraciones
Descripción: Verificar combinaciones de declaraciones de variables y constantes
Fecha: 28/04/2025
*$
WorldName PruebaCombinacionDeclaraciones:
$$ Sección de constantes con diferentes tipos y complejidades
Bedrock
$$ Constantes simples de tipos básicos
Obsidian Stack MAX_PLAYERS 8;
Obsidian Stack MIN_LEVEL 1;
Obsidian Torch DEBUG_MODE On;
Obsidian Spider GAME_TITLE "
Notch
Engine
";
Obsidian Rune SEPARATOR '_';
Obsidian Ghast GRAVITY 9.8;
$$ Constantes con expresiones
Obsidian Stack MAX_INVENTORY_SIZE 5 * 9;
Obsidian Stack TOTAL_SLOTS MAX_PLAYERS * MAX_INVENTORY_SIZE;
Obsidian Spider FULL_TITLE GAME_TITLE bind "
v1
.
0
";
Obsidian Ghast TERMINAL_VELOCITY GRAVITY :* 3.0;
$$ Constantes con expresiones más complejas
Obsidian Stack DAYS_IN_YEAR 365;
Obsidian Stack DAYS_IN_4_YEARS DAYS_IN_YEAR * 4 + 1;
Obsidian Torch IS_LEAP_YEAR (DAYS_IN_4_YEARS - (DAYS_IN_YEAR * 4)) is 1;
$$ Declaraciones de tipos con diferentes formas
ResourcePack
$$ Conversiones de tipos básicas
Anvil Ghast -> Stack;
Anvil Ghast -> Stack truncate;
Anvil Stack -> Spider;
Anvil Rune -> Stack safe;
$$ Declaraciones de entidades (registros)
Entity Item
PolloCrudo
Spider nombre;
Stack cantidad;
Stack durabilidad;
Torch stackeable;
PolloAsado;
Entity Jugador
PolloCrudo
Spider nombre;
Stack nivel;
Stack experiencia;
Ghast salud;
Ghast hambre;
Torch en_linea;
Entity Item item_principal;
PolloAsado;
Entity Posicion
PolloCrudo
Stack x;
Stack y;
Stack z;
PolloAsado;
$$ Tipos anidados
Entity Mundo
PolloCrudo
Spider nombre;
Stack seed;
Shelf[10] Entity Jugador jugadores;
Entity Posicion spawn;
PolloAsado;
$$ Sección de variables con diferentes formas de declaración e inicialización
Inventory
$$ Declaraciones simples sin inicialización
Stack contador;
Spider mensaje;
Torch estado;
Rune inicial;
Ghast temperatura;
$$ Declaraciones con inicialización
Stack nivel = 1;
Spider nombre = "
Steve
";
Torch activo = On;
Rune tecla = 'A';
Ghast pi = 3.14159;
$$ Declaraciones múltiples del mismo tipo
Stack x = 0, y = 0, z = 0;
Torch jugando = On, pausa = Off, sonido = On;
Ghast distancia = 0.0, velocidad = 5.0, aceleracion = 1.5;
$$ Declaraciones con resultados de expresiones
Stack suma = 5 + 10;
Stack producto = 4 * 25;
Spider saludo = "
Hola
" bind nombre;
Torch condicion = nivel > 5;
Ghast promedio = (10.5 :+ 20.7 :+ 15.3) :// 3.0;
$$ Declaraciones de tipos compuestos
Shelf[5] Stack inventario;
Shelf[3] Spider mensajes = ["
Hola
", "
Mundo
", "
"];
Shelf[2] Shelf[2] Stack matriz;
Chest numeros = {: 1, 2, 3, 4, 5 :};
Book archivo = {/ "
datos
.
txt
", 'E' /};
$$ Instancias de entidades (registros)
Entity Item espada;
Entity Jugador jugador1
PolloCrudo
nombre: "
Alex
";
nivel: 5;
experiencia: 150;
salud: 18.5;
hambre: 16.0;
en_linea: On;
item_principal:
PolloCrudo
nombre: "
Espada
de
diamante
";
cantidad: 1;
durabilidad: 1500;
stackeable: Off;
PolloAsado;
PolloAsado;
Entity Mundo mundo_principal;
SpawnPoint
PolloCrudo
$$ Inicialización de variables declaradas sin valor inicial
contador = 0;
mensaje = "
Variable
inicializada
en
el
punto
de
entrada
";
estado = Off;
inicial = 'Z';
temperatura = 22.5;
$$ Inicialización de variables compuestas
espada@nombre = "
Espada
de
hierro
";
espada@cantidad = 1;
espada@durabilidad = 250;
espada@stackeable = Off;
matriz[0][0] = 1;
matriz[0][1] = 2;
matriz[1][0] = 3;
matriz[1][1] = 4;
mundo_principal@nombre = "
Mundo
de
prueba
";
mundo_principal@seed = 12345;
mundo_principal@spawn@x = 0;
mundo_principal@spawn@y = 64;
mundo_principal@spawn@z = 0;
$$ Uso de constantes en asignaciones
Stack max_jugadores = MAX_PLAYERS;
dropperSpider(FULL_TITLE);
$$ Uso de referencias a variables en asignaciones
Stack total = nivel + jugador1@nivel;
dropperSpider("
Nivel
total
:
" bind total);
PolloAsado
worldSave
$*
Prueba: 41_Prueba_Comb_Expresiones
Descripción: Verificar expresiones aritméticas y lógicas complejas
Fecha: 28/04/2025
*$
WorldName PruebaExpresionesComplejas:
Bedrock
Obsidian Stack BASE_DAMAGE 10;
Obsidian Stack ARMOR_FACTOR 2;
Obsidian Ghast CRIT_MULTIPLIER 1.5;
Obsidian Torch USE_ADVANCED_FORMULAS On;
Inventory
$$ Variables para las pruebas
Stack a = 5;
Stack b = 10;
Stack c = 15;
Stack resultado_entero;
Ghast x = 2.5;
Ghast y = 3.7;
Ghast z = 1.2;
Ghast resultado_flotante;
Torch p = On;
Torch q = Off;
Torch r = On;
Torch resultado_logico;
Spider str1 = "
Notch
";
Spider str2 = "
Engine
";
Spider resultado_string;
Shelf[5] Stack valores = [10, 20, 30, 40, 50];
Entity Jugador
PolloCrudo
Spider nombre;
Stack nivel;
Ghast salud;
PolloAsado;
Entity Jugador jugador;
SpawnPoint
PolloCrudo
$$ 1. Expresiones aritméticas complejas con enteros
resultado_entero = a + b * c;
dropperSpider("
a
+
b
*
c
=
" bind resultado_entero);
resultado_entero = (a + b) * c;
dropperSpider("
(
a
+
b
)
*
c
=
" bind resultado_entero);
resultado_entero = a + b - c * 2 // 3 % 4;
dropperSpider("
a
+
b
-
c
*
2
3
%
4
=
" bind resultado_entero);
resultado_entero = (a + (b - (c * (2 // (3 % 4)))));
dropperSpider("
Anidada
enteros
:
" bind resultado_entero);
soulsand a;
resultado_entero = a + b;
magma b;
dropperSpider("
Después
de
incremento
decremento
:
" bind resultado_entero);
$$ 2. Expresiones aritméticas complejas con flotantes
resultado_flotante = x :+ y :* z;
dropperSpider("
x
:
+
y
:
*
z
=
" bind resultado_flotante);
resultado_flotante = (x :+ y) :* z;
dropperSpider("
(
x
:
+
y
)
:
*
z
=
" bind resultado_flotante);
resultado_flotante = x :+ y :- z :* 2.0 :// 0.5 :% 1.0;
dropperSpider("
x
:
+
y
:
-
z
:
*
2.0
:
0.5
:
%
1.0
=
" bind resultado_flotante);
resultado_flotante = (x :+ (y :- (z :* (2.0 :// (0.5 :% 1.0)))));
dropperSpider("
Anidada
flotantes
:
" bind resultado_flotante);
$$ 3. Expresiones lógicas complejas
resultado_logico = p and q;
dropperSpider("
p
and
q
=
" bind resultado_logico);
resultado_logico = p or q;
dropperSpider("
p
or
q
=
" bind resultado_logico);
resultado_logico = not p;
dropperSpider("
not
p
=
" bind resultado_logico);
resultado_logico = p xor q;
dropperSpider("
p
xor
q
=
" bind resultado_logico);
resultado_logico = p and q or r;
dropperSpider("
p
and
q
or
r
=
" bind resultado_logico);
resultado_logico = p and (q or r);
dropperSpider("
p
and
(
q
or
r
)
=
" bind resultado_logico);
resultado_logico = not (p and q) or (not r and p);
dropperSpider("
not
(
p
and
q
)
or
(
not
r
and
p
)
=
" bind resultado_logico);
$$ 4. Expresiones de comparación
resultado_logico = a < b;
dropperSpider("
a
<
b
=
" bind resultado_logico);
resultado_logico = a > c;
dropperSpider("
a
>
c
=
" bind resultado_logico);
resultado_logico = a <= b and b >= c;
dropperSpider("
a
<=
b
and
b
>=
c
=
" bind resultado_logico);
resultado_logico = (a is b) or (b is c);
dropperSpider("
(
a
is
b
)
or
(
b
is
c
)
=
" bind resultado_logico);
resultado_logico = a isNot b and b isNot c and a isNot c;
dropperSpider("
a
isNot
b
and
b
isNot
c
and
a
isNot
c
=
" bind resultado_logico);
$$ 5. Expresiones mixtas (combinando tipos)
resultado_logico = (a + b > c) and (x :+ y :> z);
dropperSpider("
(
a
+
b
>
c
)
and
(
x
:
+
y
:
>
z
)
=
" bind resultado_logico);
resultado_logico = (a < b) or (not p) and (x :< y);
dropperSpider("
(
a
<
b
)
or
(
not
p
)
and
(
x
:
<
y
)
=
" bind resultado_logico);
$$ 6. Expresiones con operaciones de cadenas
resultado_string = bind(str1, "
" bind str2);
dropperSpider("
bind
result
:
" bind resultado_string);
Stack longitud = #(resultado_string);
dropperSpider("
Length
:
" bind longitud);
resultado_string = from resultado_string ## 0 ## 5;
dropperSpider("
Substring
:
" bind resultado_string);
Stack pos = seek(resultado_string, "
tch
");
dropperSpider("
Position
of
'tch'
:
" bind pos);
$$ 7. Expresiones con accesos a estructuras
Stack valor_arreglo = valores[2] + valores[3] * valores[4];
dropperSpider("
Array
expression
:
" bind valor_arreglo);
jugador@nombre = "
Steve
";
jugador@nivel = 20;
jugador@salud = 18.5;
Stack nivel_con_bonus = jugador@nivel + 5;
dropperSpider("
Nivel
con
bonus
:
" bind nivel_con_bonus);
Torch nivel_alto = jugador@nivel > 15 and jugador@salud :> 15.0;
dropperSpider("
Nivel
alto
:
" bind nivel_alto);
$$ 8. Expresiones con conversiones de tipo
Stack entero_desde_float = x >> Stack;
dropperSpider("
Entero
desde
float
:
" bind entero_desde_float);
Torch bool_desde_entero = a >> Torch;
dropperSpider("
Booleano
desde
entero
:
" bind bool_desde_entero);
$$ 9. Expresiones extremadamente complejas que combinan múltiples elementos
Stack damage = BASE_DAMAGE + ((jugador@nivel // 2) * (valores[1] + valores[3] // 3));
dropperSpider("
Daño
calculado
:
" bind damage);
target USE_ADVANCED_FORMULAS craft hit
PolloCrudo
Ghast damage_final = ((damage >> Ghast) :* CRIT_MULTIPLIER) :// (1.0 :+ ((valores[4] // 10) >> Ghast));
dropperSpider("
Daño
final
(
fórmula
avanzada
)
:
" bind damage_final);
PolloAsado
miss
PolloCrudo
Stack damage_simple = damage * 2 // (ARMOR_FACTOR + (p and q >> Stack));
dropperSpider("
Daño
final
(
fórmula
simple
)
:
" bind damage_simple);
PolloAsado
PolloAsado
worldSave
$*
Prueba: 42_Prueba_Comb_Control.ne
Descripción: Verificar estructuras de control anidadas
Fecha: 28/04/2025
*$
WorldName PruebaControlAnidado:
Inventory
$$ Variables para las pruebas
Stack contador = 0;
Stack max_iteraciones = 5;
Stack resultado = 0;
Stack opcion = 2;
Torch condicion1 = On;
Torch condicion2 = Off;
Spider mensaje = "
Estructuras
de
control
anidadas
";
Spider resultado_texto = "
";
Shelf[5] Stack matriz = [1, 2, 3, 4, 5];
Entity Personaje
PolloCrudo
Spider nombre;
Stack nivel;
Torch activo;
PolloAsado;
Entity Personaje jugador;
SpawnPoint
dropperSpider(mensaje);
jugador@nombre = "
Steve
";
jugador@nivel = 1;
jugador@activo = On;
$$ 1. Condicionales anidados (if-then-else)
target jugador@nivel >= 1 craft hit
PolloCrudo
dropperSpider("
Nivel
suficiente
para
comenzar
");
target jugador@activo craft hit
PolloCrudo
dropperSpider("
Jugador
activo
");
target jugador@nombre is "
Steve
" craft hit
PolloCrudo
dropperSpider("
Bienvenido
,
Steve
");
soulsand jugador@nivel;
PolloAsado
miss
PolloCrudo
dropperSpider("
Bienvenido
,
jugador
desconocido
");
PolloAsado
PolloAsado
miss
PolloCrudo
dropperSpider("
Jugador
inactivo
.
Activando
.
.
.
");
jugador@activo = On;
PolloAsado
PolloAsado
miss
PolloCrudo
dropperSpider("
Nivel
insuficiente
para
comenzar
");
PolloAsado
$$ 2. Switch anidado dentro de if
target opcion > 0 craft hit
PolloCrudo
jukebox opcion craft
disc 1:
PolloCrudo
dropperSpider("
Opción
1
seleccionada
");
target condicion1 craft hit
PolloCrudo
dropperSpider("
Subopción
A
");
PolloAsado
miss
PolloCrudo
dropperSpider("
Subopción
B
");
PolloAsado
PolloAsado
disc 2:
PolloCrudo
dropperSpider("
Opción
2
seleccionada
");
jukebox jugador@nivel craft
disc 1:
PolloCrudo
dropperSpider("
Nivel
básico
");
PolloAsado
disc 2:
PolloCrudo
dropperSpider("
Nivel
intermedio
");
PolloAsado
silence:
PolloCrudo
dropperSpider("
Nivel
desconocido
");
PolloAsado
PolloAsado
silence:
PolloCrudo
dropperSpider("
Opción
no
reconocida
");
PolloAsado
PolloAsado
$$ 3. Bucles anidados - while dentro de for
walk i set 0 to 2 craft
PolloCrudo
dropperSpider("
Iteración
de
for
principal
:
" bind i);
Stack j = 0;
repeater j < 3 craft
PolloCrudo
dropperSpider("
Subiteración
de
while
:
" bind j);
resultado += (i * 10 + j);
soulsand j;
PolloAsado
PolloAsado
dropperSpider("
Resultado
acumulado
:
" bind resultado);
$$ 4. Bucle do-while con if anidado
contador = 0;
resultado = 0;
spawner
PolloCrudo
soulsand contador;
dropperSpider("
Iteración
do
-
while
:
" bind contador);
target contador % 2 is 0 craft hit
PolloCrudo
dropperSpider("
Número
par
detectado
");
resultado += contador;
PolloAsado
miss
PolloCrudo
dropperSpider("
Número
impar
detectado
");
resultado += contador * 2;
PolloAsado
PolloAsado
exhausted contador >= max_iteraciones;
dropperSpider("
Resultado
tras
do
-
while
:
" bind resultado);
$$ 5. Bucles for anidados con break y continue
resultado = 0;
walk i set 0 to 5 craft
PolloCrudo
target i is 3 craft hit
PolloCrudo
dropperSpider("
Saltando
iteración
i
=
3
");
enderPearl;
PolloAsado
dropperSpider("
For
externo
:
" bind i);
walk j set 0 to 3 craft
PolloCrudo
target i is 4 and j > 1 craft hit
PolloCrudo
dropperSpider("
Terminando
loop
interno
en
i
=
4
,
j
=
" bind j);
creeper;
PolloAsado
resultado += (i + j);
dropperSpider("
For
interno
:
j
=
" bind j bind "
,
suma
acumulada
=
" bind resultado);
PolloAsado
PolloAsado
$$ 6. Combinación compleja: with dentro de if-else dentro de while
contador = 0;
resultado = 0;
repeater contador < 3 craft
PolloCrudo
soulsand contador;
dropperSpider("
Iteración
while
principal
:
" bind contador);
target contador % 2 is 0 craft hit
PolloCrudo
wither jugador craft
PolloCrudo
activo = Off;
dropperSpider("
" bind nombre bind "
desactivado
temporalmente
");
spawner
PolloCrudo
soulsand nivel;
dropperSpider("
Incrementando
nivel
:
" bind nivel);
PolloAsado
exhausted nivel > contador + 2;
activo = On;
dropperSpider("
" bind nombre bind "
reactivado
con
nivel
" bind nivel);
PolloAsado
PolloAsado
miss
PolloCrudo
Stack temp_nivel = jugador@nivel;
repeater temp_nivel > 0 craft
PolloCrudo
dropperSpider("
Reduciendo
nivel
temporal
:
" bind temp_nivel);
target temp_nivel is 1 craft hit
PolloCrudo
dropperSpider("
Nivel
mínimo
alcanzado
");
creeper;
PolloAsado
magma temp_nivel;
PolloAsado
PolloAsado
PolloAsado
$$ 7. Estructuras de control con expresiones complejas en las condiciones
walk i set 0 to matriz[2] + matriz[4] // 2 craft
PolloCrudo
target (i * 2 <= matriz[i % 5]) and ((i % 2 is 0) or (i is matriz[0])) craft hit
PolloCrudo
dropperSpider("
Condición
compleja
satisfecha
en
i
=
" bind i);
resultado += i;
PolloAsado
PolloAsado
dropperSpider("
Resultado
final
:
" bind resultado);
$$ 8. Instrucción ragequit condicionada anidada
target contador >= max_iteraciones and resultado < 100 craft hit
PolloCrudo
target jugador@nivel < 5 craft hit
PolloCrudo
dropperSpider("
Condiciones
críticas
alcanzadas
.
Terminando
programa
.
");
ragequit;
PolloAsado
PolloAsado
dropperSpider("
Programa
completado
con
éxito
.
");
worldSave
$*
Prueba: 43_Prueba_Rend_MuchosTokens
Descripción: Verificar rendimiento con un archivo con miles de tokens
Fecha: 28/04/2025
*$
WorldName PruebaMuchosTokens:
Bedrock
Obsidian Stack MAX_ITERATIONS 1000;
Obsidian Stack ARRAY_SIZE 500;
Obsidian Stack STEP_VALUE 1;
Obsidian Spider TEST_NAME "
Prueba
de
rendimiento
con
muchos
tokens
";
ResourcePack
Entity TestData
PolloCrudo
Stack id;
Stack value;
Ghast weight;
Spider name;
Torch active;
PolloAsado;
Inventory
$$ Declaramos variables extensas para generar muchos tokens
Shelf[500] Stack numbers;
$$ Creamos un array grande de registros
Shelf[100] Entity TestData records;
$$ Variables para el procesamiento
Stack counter;
Stack sum;
Stack product;
Stack max_value;
Stack min_value;
Ghast average;
Stack i;
Stack j;
Stack k;
Stack temp;
Torch condition;
SpawnPoint
dropperSpider(TEST_NAME);
dropperSpider("
Inicializando
arrays
.
.
.
");
$$ Inicialización masiva del array de enteros
walk i set 0 to ARRAY_SIZE - 1 craft
PolloCrudo
numbers[i] = i * STEP_VALUE;
PolloAsado
$$ Inicialización del array de registros
walk i set 0 to 99 craft
PolloCrudo
records[i]@id = i;
records[i]@value = i * 10;
records[i]@weight = i :* 0.5;
records[i]@name = "
Item_
" bind i;
records[i]@active = i % 2 is 0;
PolloAsado
dropperSpider("
Realizando
cálculos
.
.
.
");
$$ Cálculos repetitivos generando miles de tokens
sum = 0;
product = 1;
max_value = numbers[0];
min_value = numbers[0];
$$ Bucle con muchas operaciones
walk i set 0 to ARRAY_SIZE - 1 craft
PolloCrudo
$$ Acumuladores simples
sum += numbers[i];
$$ Para evitar overflow, sólo multiplicamos los primeros 10 valores
target i < 10 craft hit
PolloCrudo
product *= numbers[i] + 1;
PolloAsado
$$ Cálculo de máximo y mínimo
target numbers[i] > max_value craft hit
PolloCrudo
max_value = numbers[i];
PolloAsado
target numbers[i] < min_value craft hit
PolloCrudo
min_value = numbers[i];
PolloAsado
$$ Operaciones condicionales adicionales
target i % 50 is 0 craft hit
PolloCrudo
dropperSpider("
Procesado
" bind i bind "
elementos
.
.
.
");
PolloAsado
PolloAsado
$$ Cálculo de promedio
average = sum >> Ghast :// (ARRAY_SIZE >> Ghast);
dropperSpider("
Procesamiento
completado
.
Resultados
:
");
dropperSpider("
Suma
total
:
" bind sum);
dropperSpider("
Producto
(
primeros
10
)
:
" bind product);
dropperSpider("
Valor
máximo
:
" bind max_value);
dropperSpider("
Valor
mínimo
:
" bind min_value);
dropperSpider("
Promedio
:
" bind average);
$$ Procesamiento de registros - para generar más tokens
dropperSpider("
Procesando
registros
.
.
.
");
counter = 0;
walk i set 0 to 99 craft
PolloCrudo
target records[i]@active craft hit
PolloCrudo
soulsand counter;
$$ Actualizar el valor basado en otros registros
walk j set 0 to i craft
PolloCrudo
records[i]@value += j;
PolloAsado
PolloAsado
PolloAsado
dropperSpider("
Registros
activos
:
" bind counter);
$$ Algoritmo de ordenamiento burbuja para generar aún más tokens
dropperSpider("
Ordenando
array
.
.
.
");
walk i set 0 to ARRAY_SIZE - 2 craft
PolloCrudo
walk j set 0 to ARRAY_SIZE - i - 2 craft
PolloCrudo
target numbers[j] > numbers[j + 1] craft hit
PolloCrudo
$$ Intercambio
temp = numbers[j];
numbers[j] = numbers[j + 1];
numbers[j + 1] = temp;
PolloAsado
PolloAsado
PolloAsado
dropperSpider("
Array
ordenado
.
");
$$ Búsqueda binaria para generar más tokens
dropperSpider("
Realizando
búsquedas
.
.
.
");
walk k set 0 to 20 craft
PolloCrudo
Stack valor_buscar = k * 25;
Stack inicio = 0;
Stack fin = ARRAY_SIZE - 1;
Stack medio;
Stack encontrado = 0;
repeater inicio <= fin craft
PolloCrudo
medio = (inicio + fin) // 2;
target numbers[medio] is valor_buscar craft hit
PolloCrudo
encontrado = 1;
creeper;
PolloAsado
target numbers[medio] < valor_buscar craft hit
PolloCrudo
inicio = medio + 1;
PolloAsado
miss
PolloCrudo
fin = medio - 1;
PolloAsado
PolloAsado
target encontrado craft hit
PolloCrudo
dropperSpider("
Valor
" bind valor_buscar bind "
encontrado
en
posición
" bind medio);
PolloAsado
miss
PolloCrudo
dropperSpider("
Valor
" bind valor_buscar bind "
no
encontrado
");
PolloAsado
PolloAsado
dropperSpider("
Prueba
de
rendimiento
completada
.
");
worldSave
$*
Prueba: 44_Prueba_Rend_TokensRepetidos
Descripción: Verificar rendimiento con patrones repetitivos
Fecha: 28/04/2025
*$
WorldName PruebaTokensRepetidos:
Bedrock
Obsidian Stack MAX_ITERATIONS 500;
Obsidian Stack PATTERN_LENGTH 20;
Inventory
$$ Variables para la prueba
Stack counter = 0;
Stack total = 0;
Stack temp = 0;
Torch flag = On;
SpawnPoint
dropperSpider("
Iniciando
prueba
de
rendimiento
con
tokens
repetitivos
");
$$ =================================================================
$$ Patrón 1: Repetición masiva de operaciones aritméticas
$$ =================================================================
counter = 0;
total = 0;
repeater counter < MAX_ITERATIONS craft
PolloCrudo
$$ Patrón de operaciones aritméticas que se repite
total = total + 1;
total = total - 1;
total = total + 2;
total = total - 1;
total = total + 3;
total = total - 2;
total = total * 2;
total = total // 2;
total = total + 5;
total = total % 10;
total = total + 1;
total = total - 1;
total = total + 2;
total = total - 1;
total = total + 3;
total = total - 2;
total = total * 2;
total = total // 2;
total = total + 5;
total = total % 10;
soulsand counter;
PolloAsado
dropperSpider("
Patrón
1
completado
.
Total
:
" bind total);
$$ =================================================================
$$ Patrón 2: Repetición masiva de operaciones lógicas
$$ =================================================================
counter = 0;
flag = On;
repeater counter < MAX_ITERATIONS craft
PolloCrudo
$$ Patrón de operaciones lógicas que se repite
flag = flag and On;
flag = flag or Off;
flag = not flag;
flag = flag and On;
flag = flag or Off;
flag = not flag;
flag = flag xor On;
flag = flag xor Off;
flag = flag and On;
flag = not flag;
flag = flag and On;
flag = flag or Off;
flag = not flag;
flag = flag and On;
flag = flag or Off;
flag = not flag;
flag = flag xor On;
flag = flag xor Off;
flag = flag and On;
flag = not flag;
soulsand counter;
PolloAsado
dropperSpider("
Patrón
2
completado
.
Estado
final
:
" bind flag);
$$ =================================================================
$$ Patrón 3: Repetición masiva de evaluaciones condicionales
$$ =================================================================
counter = 0;
total = 0;
repeater counter < MAX_ITERATIONS craft
PolloCrudo
$$ Patrón de condicionales que se repite
target counter % 2 is 0 craft hit
PolloCrudo
total += 1;
PolloAsado
miss
PolloCrudo
total += 2;
PolloAsado
target counter % 3 is 0 craft hit
PolloCrudo
total += 3;
PolloAsado
miss
PolloCrudo
total += 1;
PolloAsado
target counter % 5 is 0 craft hit
PolloCrudo
total += 5;
PolloAsado
miss
PolloCrudo
total += 2;
PolloAsado
target counter % 7 is 0 craft hit
PolloCrudo
total += 7;
PolloAsado
miss
PolloCrudo
total += 3;
PolloAsado
target total > 1000 craft hit
PolloCrudo
total = total % 1000;
PolloAsado
soulsand counter;
PolloAsado
dropperSpider("
Patrón
3
completado
.
Total
:
" bind total);
$$ =================================================================
$$ Patrón 4: Repetición masiva de incremento/decremento
$$ =================================================================
counter = 0;
total = 500;
repeater counter < MAX_ITERATIONS craft
PolloCrudo
$$ Patrón de incremento/decremento que se repite
soulsand total;
soulsand total;
soulsand total;
magma total;
magma total;
soulsand total;
soulsand total;
magma total;
soulsand total;
magma total;
soulsand total;
soulsand total;
soulsand total;
magma total;
magma total;
soulsand total;
soulsand total;
magma total;
soulsand total;
magma total;
soulsand counter;
PolloAsado
dropperSpider("
Patrón
4
completado
.
Total
:
" bind total);
$$ =================================================================
$$ Patrón 5: Repetición masiva de operaciones de asignación compuesta
$$ =================================================================
counter = 0;
total = 5;
repeater counter < MAX_ITERATIONS craft
PolloCrudo
$$ Patrón de asignaciones compuestas que se repite
total += 5;
total -= 2;
total *= 2;
total //= 2;
total %= 10;
total += 1;
total -= 1;
total *= 3;
total //= 3;
total %= 5;
total += 5;
total -= 2;
total *= 2;
total //= 2;
total %= 10;
total += 1;
total -= 1;
total *= 3;
total //= 3;
total %= 5;
soulsand counter;
PolloAsado
dropperSpider("
Patrón
5
completado
.
Total
:
" bind total);
$$ =================================================================
$$ Patrón 6: Repetición masiva de operadores de comparación
$$ =================================================================
counter = 0;
total = 0;
temp = 50;
repeater counter < MAX_ITERATIONS craft
PolloCrudo
$$ Patrón de comparaciones que se repite
target counter < temp craft hit total += 1; PolloAsado
target counter > temp craft hit total += 1; PolloAsado
target counter <= temp craft hit total += 1; PolloAsado
target counter >= temp craft hit total += 1; PolloAsado
target counter is temp craft hit total += 1; PolloAsado
target counter isNot temp craft hit total += 1; PolloAsado
target counter < 100 craft hit total += 1; PolloAsado
target counter > 0 craft hit total += 1; PolloAsado
target counter <= 100 craft hit total += 1; PolloAsado
target counter >= 0 craft hit total += 1; PolloAsado
target counter < temp craft hit total += 1; PolloAsado
target counter > temp craft hit total += 1; PolloAsado
target counter <= temp craft hit total += 1; PolloAsado
target counter >= temp craft hit total += 1; PolloAsado
target counter is temp craft hit total += 1; PolloAsado
target counter isNot temp craft hit total += 1; PolloAsado
target counter < 100 craft hit total += 1; PolloAsado
target counter > 0 craft hit total += 1; PolloAsado
target counter <= 100 craft hit total += 1; PolloAsado
target counter >= 0 craft hit total += 1; PolloAsado
soulsand counter;
PolloAsado
dropperSpider("
Patrón
6
completado
.
Total
:
" bind total);
dropperSpider("
Prueba
de
rendimiento
con
tokens
repetitivos
completada
.
");
worldSave
$*
Prueba: 45_Prueba_Rend_TokensVariados
Descripción: Verificar rendimiento con variedad de tokens mezclados
Fecha: 28/04/2025
*$
WorldName PruebaTokensVariados:
$$ Sección de constantes para controlar el tamaño de la prueba
Bedrock
Obsidian Stack ITERATIONS 100;
Obsidian Stack MAX_VALUE 1000;
Obsidian Stack ARRAY_SIZE 50;
Obsidian Spider TEST_NAME "
Prueba
de
rendimiento
con
tokens
variados
";
Obsidian Spider VERSION "
1.0
";
Obsidian Ghast PI 3.14159;
Obsidian Torch DEBUG_MODE On;
$$ Definiciones de tipos variados para generar diversidad de tokens
ResourcePack
Entity Posicion
PolloCrudo
Stack x;
Stack y;
Stack z;
PolloAsado;
Entity Item
PolloCrudo
Spider nombre;
Stack cantidad;
Stack durabilidad;
Ghast peso;
Torch consumible;
PolloAsado;
Entity Jugador
PolloCrudo
Spider nombre;
Stack nivel;
Ghast salud;
Entity Posicion posicion;
Shelf[10] Entity Item inventario;
PolloAsado;
Anvil Ghast -> Stack truncate;
Anvil Stack -> Spider;
Anvil Spider -> Stack;
Anvil Stack -> Torch;
Inventory
Stack contador = 0;
Stack suma = 0;
Stack producto = 1;
Ghast pi = 3.14159;
Ghast e = 2.71828;
Ghast resultado_flotante = 0.0;
Spider texto = "
Prueba
de
rendimiento
";
Spider resultado_texto = "
";
Rune caracter = 'A';
Torch condicion = On;
Shelf[ARRAY_SIZE] Stack numeros;
Shelf[ARRAY_SIZE] Ghast valores_reales;
Shelf[10] Spider textos = ["
uno
", "
dos
", "
tres
", "
cuatro
", "
cinco
", "
seis
", "
siete
", "
ocho
", "
nueve
", "
diez
"];
Chest conjunto_numeros = {: 1, 2, 3, 4, 5 :};
Chest conjunto_caracteres = {: 'a', 'b', 'c', 'd', 'e' :};
Book archivo_log = {/ "
log
.
txt
", 'E' /};
Book archivo_datos = {/ "
datos
.
dat
", 'L' /};
Entity Posicion origen
PolloCrudo
x: 0;
y: 0;
z: 0;
PolloAsado;
Entity Item espada
PolloCrudo
nombre: "
Espada
de
diamante
";
cantidad: 1;
durabilidad: 1000;
peso: 5.0;
consumible: Off;
PolloAsado;
Entity Jugador jugador_principal;
Entity Jugador jugadores[5];
Recipe
Spell calcularDanio(Stack :: nivel; Ghast :: multiplicador) -> Stack;
Spell distanciaEntre(Entity Posicion :: pos1, pos2) -> Ghast;
Spell crearItem(Spider :: nombre; Stack cantidad, durabilidad; Ghast peso; Torch consumible) -> Entity Item;
Ritual inicializarJugador(Entity Jugador ref jugador; Spider :: nombre; Stack nivel; Ghast salud);
Ritual mostrarEstadisticas(Entity Jugador :: jugador);
Ritual procesarInventario(Shelf[10] Entity Item :: inventario);
CraftingTable
Spell calcularDanio(Stack :: nivel; Ghast :: multiplicador) -> Stack
PolloCrudo
Stack danio_base = nivel * 2 + 5;
Stack danio_final = danio_base;
target nivel > 10 craft hit
PolloCrudo
danio_final += (nivel - 10) * 3;
PolloAsado
Ghast temp = danio_final >> Ghast;
temp = temp :* multiplicador;
danio_final = temp >> Stack;
respawn danio_final;
PolloAsado
Spell distanciaEntre(Entity Posicion :: pos1, pos2) -> Ghast
PolloCrudo
Stack dx = pos1@x - pos2@x;
Stack dy = pos1@y - pos2@y;
Stack dz = pos1@z - pos2@z;
Ghast dx_float = dx >> Ghast;
Ghast dy_float = dy >> Ghast;
Ghast dz_float = dz >> Ghast;
Ghast suma_cuadrados = (dx_float :* dx_float) :+ (dy_float :* dy_float) :+ (dz_float :* dz_float);
Ghast result = suma_cuadrados :// 2.0;
respawn result;
PolloAsado
Spell crearItem(Spider :: nombre; Stack cantidad, durabilidad; Ghast peso; Torch consumible) -> Entity Item
PolloCrudo
Entity Item nuevo_item
PolloCrudo
nombre: nombre;
cantidad: cantidad;
durabilidad: durabilidad;
peso: peso;
consumible: consumible;
PolloAsado;
respawn nuevo_item;
PolloAsado
Ritual inicializarJugador(Entity Jugador ref jugador; Spider :: nombre; Stack nivel; Ghast salud)
PolloCrudo
jugador@nombre = nombre;
jugador@nivel = nivel;
jugador@salud = salud;
jugador@posicion@x = 0;
jugador@posicion@y = 0;
jugador@posicion@z = 0;
walk i set 0 to 9 craft
PolloCrudo
jugador@inventario[i] = crearItem("
Item_
" bind i, i + 1, 100 * (i + 1), i :* 0.5, i % 2 is 0);
PolloAsado
PolloAsado
Ritual mostrarEstadisticas(Entity Jugador :: jugador)
PolloCrudo
dropperSpider("
==
=
Estadísticas
del
Jugador
==
=
");
dropperSpider("
Nombre
:
" bind jugador@nombre);
dropperSpider("
Nivel
:
" bind jugador@nivel);
dropperSpider("
Salud
:
" bind jugador@salud);
dropperSpider("
Posición
:
(
" bind jugador@posicion@x bind "
,
" bind jugador@posicion@y bind "
,
" bind jugador@posicion@z bind "
)
");
dropperSpider("
Inventario
:
" bind #(jugador@inventario) bind "
items
");
PolloAsado
Ritual procesarInventario(Shelf[10] Entity Item :: inventario)
PolloCrudo
Stack total_items = 0;
Ghast peso_total = 0.0;
Spider lista_items = "
";
walk i set 0 to 9 craft
PolloCrudo
total_items += inventario[i]@cantidad;
peso_total = peso_total :+ (inventario[i]@peso :* inventario[i]@cantidad >> Ghast);
target i < 9 craft hit
PolloCrudo
lista_items = lista_items bind inventario[i]@nombre bind "
,
";
PolloAsado
miss
PolloCrudo
lista_items = lista_items bind inventario[i]@nombre;
PolloAsado
PolloAsado
dropperSpider("
Total
items
:
" bind total_items);
dropperSpider("
Peso
total
:
" bind peso_total);
dropperSpider("
Lista
:
" bind lista_items);
PolloAsado
SpawnPoint
dropperSpider(TEST_NAME bind "
v
" bind VERSION);
walk i set 0 to ARRAY_SIZE - 1 craft
PolloCrudo
numeros[i] = (i * i + i) % MAX_VALUE;
valores_reales[i] = i :* PI :// 10.0;
target i < 20 craft hit
PolloCrudo
add(conjunto_numeros, i * 10);
PolloAsado
PolloAsado
jugador_principal@nombre = "
Aventurero
";
jugador_principal@nivel = 25;
jugador_principal@salud = 95.5;
jugador_principal@posicion@x = 100;
jugador_principal@posicion@y = 64;
jugador_principal@posicion@z = -50;
walk i set 0 to 4 craft
PolloCrudo
Spider nombre_jugador = "
Jugador_
" bind i;
Stack nivel_inicial = 1 + i * 5;
Ghast salud_inicial = 20.0 :+ (i :* 5.0);
ender_pearl inicializarJugador(jugadores[i], nombre_jugador, nivel_inicial, salud_inicial);
PolloAsado
dropperSpider("
Realizando
operaciones
mezcladas
.
.
.
");
contador = 0;
suma = 0;
producto = 1;
resultado_texto = "
";
walk iteracion set 0 to ITERATIONS - 1 craft
PolloCrudo
Stack indice = iteracion % ARRAY_SIZE;
suma += numeros[indice];
target producto < 1000000 craft hit
PolloCrudo
producto *= (indice + 1);
PolloAsado
Ghast valor_real = valores_reales[indice];
resultado_flotante = resultado_flotante :+ valor_real;
target resultado_flotante :> 1000.0 craft hit
PolloCrudo
resultado_flotante = resultado_flotante :% 1000.0;
PolloAsado
Spider texto_iteracion = textos[iteracion % 10];
target iteracion % 5 is 0 craft hit
PolloCrudo
resultado_texto = resultado_texto bind texto_iteracion;
PolloAsado
target iteracion % 2 is 0 craft hit
PolloCrudo
caracter = etchUp(caracter);
PolloAsado
miss
PolloCrudo
caracter = etchDown(caracter);
PolloAsado
condicion = condicion xor (iteracion % 3 is 0);
target indice % 2 is 0 and condicion craft hit
PolloCrudo
soulsand contador;
PolloAsado
target iteracion % 10 is 0 craft hit
PolloCrudo
Stack danio = calcularDanio(jugador_principal@nivel, 1.5);
Ghast distancia = distanciaEntre(jugador_principal@posicion, origen);
dropperSpider("
Iteración
" bind iteracion bind "
:
Daño
=
" bind danio bind "
,
Distancia
=
" bind distancia);
PolloAsado
Stack jugador_indice = iteracion % 5;
soulsand jugadores[jugador_indice]@nivel;
target iteracion % 20 is 0 craft hit
PolloCrudo
ender_pearl mostrarEstadisticas(jugadores[jugador_indice]);
PolloAsado
PolloAsado
dropperSpider("
Prueba
completada
.
Resultados
:
");
dropperSpider("
Suma
total
:
" bind suma);
dropperSpider("
Producto
acumulado
:
" bind producto);
dropperSpider("
Resultado
flotante
:
" bind resultado_flotante);
dropperSpider("
Texto
resultante
:
" bind resultado_texto);
dropperSpider("
Caracter
final
:
" bind caracter);
dropperSpider("
Contador
incrementado
:
" bind contador);
dropperSpider("
Estado
de
condición
final
:
" bind condicion);
ender_pearl procesarInventario(jugador_principal@inventario);
dropperSpider("
Prueba
de
rendimiento
con
tokens
variados
finalizada
");
worldSave
$*
Prueba_PR_Estructura.ne
Propósito: Verificar el reconocimiento de palabras reservadas de estructura del programa
Probar: WorldName, Bedrock, ResourcePack, Inventory, Recipe, CraftingTable, SpawnPoint
Fecha: 28/04/2025
*$
$$ Prueba de la estructura básica del programa NotchEngine
$$ Verificando las palabras reservadas: WorldName, Bedrock, ResourcePack, Inventory, Recipe, CraftingTable, SpawnPoint
WorldName PruebaEstructura:
Bedrock
Obsidian Stack MAX_VALOR 100;
Obsidian Spider SALUDO "
Prueba
de
estructura
";
ResourcePack
Anvil Stack -> Spider;
Inventory
Stack contador = 0;
Spider mensaje = "
Hola
mundo
";
Recipe
Spell sumar(Stack :: a, b) -> Stack;
Ritual mostrarMensaje(Spider :: texto);
CraftingTable
Spell sumar(Stack :: a, b) -> Stack
PolloCrudo
Stack resultado = a + b;
respawn resultado;
PolloAsado
Ritual mostrarMensaje(Spider :: texto)
PolloCrudo
dropperSpider(texto);
PolloAsado
SpawnPoint
PolloCrudo
dropperSpider(SALUDO);
Stack resultado = sumar(5, 10);
dropperSpider("
El
resultado
es
:
" bind resultado);
PolloAsado
worldSave
$*
Prueba_PR_Tipos.ne
Propósito: Verificar reconocimiento de tipos de datos en NotchEngine
Probar: Stack, Rune, Spider, Torch, Chest, Book, Ghast, Shelf, Entity
Fecha: 28/04/2025
*$
$$ Prueba de los tipos de datos en NotchEngine
$$ Verificando: Stack, Rune, Spider, Torch, Chest, Book, Ghast, Shelf, Entity
WorldName PruebaTipos:
Inventory
$$ Declaraciones de variables de cada tipo
$$ Stack - Tipo de dato entero
Stack entero = 42;
$$ Rune - Tipo de dato carácter
Rune caracter = 'N';
$$ Spider - Tipo de dato string
Spider texto = "
NotchEngine
";
$$ Torch - Tipo de dato booleano
Torch verdadero = On;
Torch falso = Off;
$$ Chest - Tipo de dato conjunto
Chest numeros = {: 1, 2, 3, 4, 5 :};
$$ Book - Tipo de dato archivo de texto
Book archivo = {/ "
datos
.
txt
", 'E' /};
$$ Ghast - Tipo de datos números flotantes
Ghast decimal = 3.14159;
$$ Shelf - Tipo de dato arreglos
Shelf[5] Stack arreglo = [1, 2, 3, 4, 5];
$$ Entity - Tipo de dato registros
Entity Jugador
PolloCrudo
Spider nombre;
Stack nivel;
Ghast salud;
PolloAsado;
Entity Jugador jugador = {nombre: "
Steve
", nivel: 1, salud: 20.0};
SpawnPoint
PolloCrudo
dropperSpider("
Prueba
de
tipos
completada
");
PolloAsado
worldSave
$*
Prueba_PR_Booleanos.ne
Propósito: Verificar reconocimiento de literales booleanas (On, Off)
Probar: Torch, And, Or, Not
Fecha: 28/04/2025
*$
$$ Prueba de literales booleanas en NotchEngine
$$ Verificando: On, Off
WorldName PruebaBooleanos:
Bedrock
Obsidian Torch VERDADERO On;
Obsidian Torch FALSO Off;
Inventory
$$ Declaración e inicialización con valores booleanos
Torch activo = On;
Torch inactivo = Off;
$$ Variables para almacenar resultados de operaciones lógicas
Torch resultado1;
Torch resultado2;
Torch resultado3;
Torch resultado4;
Torch resultado5;
SpawnPoint
PolloCrudo
$$ Mostrar valores booleanos directos
dropperSpider("
Valor
de
On
:
");
dropperTorch(On);
dropperSpider("
Valor
de
Off
:
");
dropperTorch(Off);
$$ Operaciones lógicas con literales booleanas
resultado1 = On and On;
dropperSpider("
On
and
On
:
");
dropperTorch(resultado1);
resultado2 = On and Off;
dropperSpider("
On
and
Off
:
");
dropperTorch(resultado2);
resultado3 = On or Off;
dropperSpider("
On
or
Off
:
");
dropperTorch(resultado3);
resultado4 = Off or Off;
dropperSpider("
Off
or
Off
:
");
dropperTorch(resultado4);
resultado5 = not On;
dropperSpider("
not
On
:
");
dropperTorch(resultado5);
$$ Uso en estructuras de control
target On craft hit
PolloCrudo
dropperSpider("
Condición
On
es
verdadera
");
PolloAsado
target Off craft hit
PolloCrudo
dropperSpider("
Esto
no
debería
mostrarse
");
PolloAsado
miss
PolloCrudo
dropperSpider("
Condición
Off
es
falsa
");
PolloAsado
PolloAsado
worldSave
$*
Prueba_PR_Bloques.ne
Propósito: Verificar reconocimiento de delimitadores de bloques (PolloCrudo, PolloAsado)
Probar: PolloCrudo, PolloAsado
Fecha: 28/04/2025
*$
$$ Prueba de delimitadores de bloques en NotchEngine
$$ Verificando: PolloCrudo, PolloAsado
WorldName PruebaBloques:
Inventory
$$ Variables para las pruebas
Stack contador = 0;
Stack acumulador = 0;
Stack resultado = 0;
Spider mensaje = "
Prueba
de
bloques
PolloCrudo
y
PolloAsado
";
CraftingTable
$$ Función con bloques de código
Spell sumarPares(Stack :: limite) -> Stack
PolloCrudo
Stack suma = 0;
$$ Bloque anidado dentro de una estructura de control
walk i set 1 to limite craft
PolloCrudo
target i % 2 is 0 craft hit
PolloCrudo
suma += i;
PolloAsado
PolloAsado
respawn suma;
PolloAsado
$$ Función con diferentes niveles de anidamiento de bloques
Spell calcularFactorial(Stack :: n) -> Stack
PolloCrudo
target n <= 1 craft hit
PolloCrudo
respawn 1;
PolloAsado
$$ Bloque dentro de una expresión
Stack resultado = n * calcularFactorial(n - 1);
respawn resultado;
PolloAsado
SpawnPoint
$$ Bloque principal
PolloCrudo
$$ Bloque simple
PolloCrudo
contador = 5;
dropperSpider(mensaje);
PolloAsado
$$ Bloque dentro de una estructura repeater
repeater contador > 0 craft
PolloCrudo
acumulador += contador;
magma contador;
$$ Bloque anidado dentro de un condicional dentro de un bucle
target contador is 2 craft hit
PolloCrudo
dropperSpider("
Contador
es
igual
a
2
");
$$ Otro bloque más anidado
PolloCrudo
dropperSpider("
Este
es
un
bloque
muy
anidado
");
PolloAsado
PolloAsado
PolloAsado
$$ Uso de bloques en estructura condicional
target acumulador > 10 craft hit
PolloCrudo
dropperSpider("
Acumulador
es
mayor
que
10
");
PolloAsado
miss
PolloCrudo
dropperSpider("
Acumulador
es
menor
o
igual
a
10
");
PolloAsado
$$ Bloque en estructura spawner-exhausted
spawner
PolloCrudo
soulsand resultado;
target resultado > 5 craft hit creeper;
PolloAsado
exhausted resultado > 10;
dropperSpider("
Valor
final
del
resultado
:
" bind resultado);
PolloAsado
worldSave
$*
Prueba_PR_Control.ne
Propósito: Verificar reconocimiento de palabras de control de flujo
Probar: Entity, PolloCrudo, PolloAsado, Punto, SpawnPoint, Inventory, WorldName
Fecha: 28/04/2025
*$
$$ Prueba de palabras reservadas de control de flujo en NotchEngine
$$ Verificando: repeater, craft, target, hit, miss, jukebox, disc, silence,
$$ spawner, exhausted, walk, set, to, step, wither
WorldName PruebaControl:
Inventory
$$ Variables para las pruebas
Stack contador = 0;
Stack opcion = 2;
Torch condicion = On;
Stack iterador = 0;
Entity Punto
PolloCrudo
Stack x;
Stack y;
PolloAsado;
Entity Punto coordenada;
SpawnPoint
PolloCrudo
$$ 1. Prueba de repeater (while) con craft
dropperSpider("
Prueba
de
repeater
:
");
contador = 5;
repeater contador > 0 craft
PolloCrudo
dropperStack(contador);
magma contador;
PolloAsado
$$ 2. Prueba de target (if) con hit y miss
dropperSpider("
Prueba
de
target
con
hit
y
miss
:
");
target condicion craft hit
PolloCrudo
dropperSpider("
Condición
es
verdadera
");
PolloAsado
miss
PolloCrudo
dropperSpider("
Condición
es
falsa
");
PolloAsado
$$ 3. Prueba de jukebox (switch) con disc y silence
dropperSpider("
Prueba
de
jukebox
con
disc
y
silence
:
");
jukebox opcion craft
disc 1:
PolloCrudo
dropperSpider("
Opción
1
seleccionada
");
PolloAsado
disc 2:
PolloCrudo
dropperSpider("
Opción
2
seleccionada
");
PolloAsado
silence:
PolloCrudo
dropperSpider("
Ninguna
opción
válida
seleccionada
");
PolloAsado
$$ 4. Prueba de spawner (do-while) con exhausted
dropperSpider("
Prueba
de
spawner
con
exhausted
:
");
contador = 0;
spawner
PolloCrudo
soulsand contador;
dropperStack(contador);
PolloAsado
exhausted contador >= 3;
$$ 5. Prueba de walk (for) con set, to, step
dropperSpider("
Prueba
de
walk
con
set
,
to
,
step
:
");
walk i set 0 to 10 step 2 craft
PolloCrudo
dropperStack(i);
PolloAsado
$$ 6. Prueba de wither (with)
dropperSpider("
Prueba
de
wither
:
");
coordenada@x = 10;
coordenada@y = 20;
wither coordenada craft
PolloCrudo
dropperSpider("
Coordenadas
:
(
" bind x bind "
,
" bind y bind "
)
");
PolloAsado
PolloAsado
worldSave
$*
Prueba_PR_Saltos.ne
Propósito: Verificar palabras para saltos y terminación (creeper, enderPearl, ragequit)
Fecha: 28/04/2025
*$
$$ Prueba de palabras reservadas para saltos y terminación en NotchEngine
$$ Verificando: creeper, enderPearl, ragequit
WorldName PruebaSaltos:
Inventory
$$ Variables para las pruebas
Stack contador = 0;
Stack totalPares = 0;
Stack totalImpares = 0;
Torch errorCritico = Off;
SpawnPoint
PolloCrudo
$$ 1. Prueba de creeper (break) para salir de un bucle
dropperSpider("
Prueba
de
creeper
(
break
)
:
");
walk i set 1 to 10 craft
PolloCrudo
dropperSpider("
Iteración
:
" bind i);
$$ Salimos del bucle cuando i llega a 5
target i is 5 craft hit
PolloCrudo
dropperSpider("
Encontrado
5
,
saliendo
del
bucle
con
creeper
");
creeper;
PolloAsado
PolloAsado
$$ 2. Prueba de enderPearl (continue) para saltar a la siguiente iteración
dropperSpider("
Prueba
de
enderPearl
(
continue
)
:
");
walk i set 1 to 10 craft
PolloCrudo
$$ Saltamos los números pares
target i % 2 is 0 craft hit
PolloCrudo
dropperSpider("
Número
par
" bind i bind "
,
saltando
con
enderPearl
");
enderPearl;
PolloAsado
$$ Esta parte solo se ejecuta para números impares
dropperSpider("
Procesando
número
impar
:
" bind i);
totalImpares += i;
PolloAsado
dropperSpider("
Total
de
números
impares
:
" bind totalImpares);
$$ 3. Prueba de creeper y enderPearl en bucles anidados
dropperSpider("
Prueba
de
control
de
flujo
en
bucles
anidados
:
");
walk i set 1 to 5 craft
PolloCrudo
walk j set 1 to 5 craft
PolloCrudo
$$ Saltar la iteración cuando j es 3
target j is 3 craft hit
PolloCrudo
dropperSpider("
Saltando
j
=
3
con
enderPearl
");
enderPearl;
PolloAsado
$$ Salir del bucle interno cuando j es 4
target j is 4 craft hit
PolloCrudo
dropperSpider("
Saliendo
del
bucle
interno
con
creeper
en
j
=
4
");
creeper;
PolloAsado
dropperSpider("
i
=
" bind i bind "
,
j
=
" bind j);
PolloAsado
PolloAsado
$$ 4. Prueba de ragequit (halt) para terminar el programa
$$ Nota: Esta parte debe estar comentada en pruebas reales
$$ o al final del programa, ya que detiene la ejecución
dropperSpider("
Prueba
de
ragequit
(
halt
)
:
");
target errorCritico craft hit
PolloCrudo
dropperSpider("
Error
crítico
detectado
,
terminando
programa
con
ragequit
");
$$ ragequit; $$ Comentado para evitar terminar la prueba
PolloAsado
dropperSpider("
Esta
línea
se
mostrará
si
errorCritico
es
Off
");
$$ Ejemplo descomentado pero que nunca se ejecutará
target Off craft hit
PolloCrudo
dropperSpider("
Esta
condición
nunca
se
cumple
");
ragequit;
PolloAsado
PolloAsado
worldSave
$*
Prueba_PR_Funciones.ne
Propósito: Verificar palabras para funciones y procedimientos (Spell, Ritual, respawn, ender_pearl)
Probar: Spell, Ritual, respawn, ender_pearl, crafting_table
Fecha: 28/04/2025
*$
$$ Prueba de palabras reservadas para funciones y procedimientos en NotchEngine
$$ Verificando: Spell, Ritual, respawn
WorldName PruebaFunciones:
$$ Sección de prototipos
Recipe
$$ Prototipos de funciones (Spell)
Spell sumar(Stack :: a, b) -> Stack;
Spell factorial(Stack :: n) -> Stack;
Spell esPar(Stack :: numero) -> Torch;
Spell sumarArreglo(Shelf[10] Stack :: numeros; Stack tamano) -> Stack;
$$ Prototipos de procedimientos (Ritual)
Ritual imprimirLinea(Spider :: texto);
Ritual mostrarResultado(Spider :: operacion; Stack valor);
Ritual imprimirArreglo(Shelf[10] Stack :: arr; Stack tamano);
$$ Sección de rutinas (implementación de funciones y procedimientos)
CraftingTable
$$ Funciones (Spell) con instrucción de retorno (respawn)
Spell sumar(Stack :: a, b) -> Stack
PolloCrudo
$$ Retorno con expresión simple
respawn a + b;
PolloAsado
Spell factorial(Stack :: n) -> Stack
PolloCrudo
$$ Retorno temprano con condición
target n <= 1 craft hit
PolloCrudo
respawn 1;
PolloAsado
$$ Retorno con expresión compleja y llamada recursiva
respawn n * factorial(n - 1);
PolloAsado
Spell esPar(Stack :: numero) -> Torch
PolloCrudo
target numero % 2 is 0 craft hit
PolloCrudo
respawn On;
PolloAsado
miss
PolloCrudo
respawn Off;
PolloAsado
PolloAsado
Spell sumarArreglo(Shelf[10] Stack :: numeros; Stack tamano) -> Stack
PolloCrudo
Stack suma = 0;
$$ Verificar parámetros
target tamano <= 0 craft hit
PolloCrudo
respawn 0; $$ Retorno temprano
PolloAsado
$$ Sumar elementos del arreglo
walk i set 0 to tamano - 1 craft
PolloCrudo
suma += numeros[i];
PolloAsado
respawn suma; $$ Retorno al final
PolloAsado
$$ Procedimientos (Ritual) con posibles retornos vacíos
Ritual imprimirLinea(Spider :: texto)
PolloCrudo
dropperSpider(texto);
dropperSpider("
--
--
--
--
--
--
--
--
--
--
--
--
");
PolloAsado
Ritual mostrarResultado(Spider :: operacion; Stack valor)
PolloCrudo
dropperSpider(operacion bind "
:
" bind valor);
$$ Retorno temprano sin valor
target valor < 0 craft hit
PolloCrudo
dropperSpider("
Valor
negativo
");
respawn; $$ Retorno vacío temprano
PolloAsado
dropperSpider("
Valor
válido
procesado
");
PolloAsado
Ritual imprimirArreglo(Shelf[10] Stack :: arr; Stack tamano)
PolloCrudo
target tamano <= 0 craft hit
PolloCrudo
dropperSpider("
Arreglo
vacío
");
respawn; $$ Retorno vacío temprano
PolloAsado
dropperSpider("
Elementos
del
arreglo
:
");
walk i set 0 to tamano - 1 craft
PolloCrudo
dropperStack(arr[i]);
PolloAsado
PolloAsado
$$ Punto de entrada con llamadas a funciones y procedimientos
SpawnPoint
PolloCrudo
$$ Declaración de variables
Stack a = 5;
Stack b = 7;
Stack resultado;
Shelf[10] Stack numeros;
$$ Inicializar arreglo
walk i set 0 to 9 craft
PolloCrudo
numeros[i] = i + 1;
PolloAsado
$$ Llamadas a funciones (invocación directa)
resultado = sumar(a, b);
dropperSpider("
Suma
:
" bind resultado);
resultado = factorial(5);
dropperSpider("
Factorial
de
5
:
" bind resultado);
Torch esPar5 = esPar(5);
dropperSpider("
Es
5
par
:
");
dropperTorch(esPar5);
resultado = sumarArreglo(numeros, 10);
dropperSpider("
Suma
del
arreglo
:
" bind resultado);
$$ Llamadas a procedimientos
imprimirLinea("
==
==
Resultados
de
pruebas
==
==
");
mostrarResultado("
Suma
de
5
y
7
", sumar(a, b));
mostrarResultado("
Valor
negativo
", -10);
imprimirArreglo(numeros, 5);
imprimirArreglo(numeros, 0);
PolloAsado
worldSave
$*
Prueba_PR_Operadores.ne
Propósito: Verificar operadores textuales reales en Notch Engine
Probar: soulsand, magma, and, or, not, xor, bind, #, from ##, except ##, seek,
add, drop, feed, map, biom, void, isEngraved, isInscribed, etchUp, etchDown,
unlock, lock, make, gather, forge, expand
Fecha: 28/04/2025
*$
WorldName PruebaOperadores:
Inventory {
Stack contador = 5; $$ Inicializa contador con 5
Torch condicion1 = On; $$ Condición 1 es verdadera
Torch condicion2 = Off; $$ Condición 2 es falsa
Torch resultado; $$ Variable para almacenar resultados booleanos
Spider texto1 = "
Notch
"; $$ Texto inicial "
Notch
"
Spider texto2 = "
Engine
"; $$ Texto inicial "
Engine
"
Spider textoCompleto; $$ Variable para texto combinado
Rune letra = 'a'; $$ Letra inicial 'a'
Rune letraMayuscula; $$ Variable para letra mayúscula
Chest conjunto1 = {: 1, 2, 3 :}; $$ Conjunto inicial con 1, 2, 3
Chest conjunto2 = {: 3, 4, 5 :}; $$ Conjunto inicial con 3, 4, 5
Chest conjuntoResultado; $$ Variable para resultado de conjuntos
Book archivo1 = {/ "
datos
.
txt
", 'E' /}; $$ Archivo para escritura "
datos
.
txt
"
Book archivo2 = {/ "
resultado
.
txt
", 'E' /}; $$ Archivo para escritura "
resultado
.
txt
"
Ghast flotante1 = 3.5; $$ Flotante inicial 3.5
Ghast flotante2 = 2.5; $$ Flotante inicial 2.5
Ghast resultadoFlotante; $$ Variable para resultado de operaciones flotantes
}
SpawnPoint {
PolloCrudo
$$ soulsand y magma
soulsand contador; $$ Aplica soulsand a contador
magma contador; $$ Aplica magma a contador
$$ and, or, not, xor
resultado = condicion1 and condicion2; $$ Resultado es verdadero si ambas condiciones son verdaderas
resultado = condicion1 or condicion2; $$ Resultado es verdadero si al menos una condición es verdadera
resultado = not condicion1; $$ Resultado es el opuesto de condicion1
resultado = condicion1 xor condicion2; $$ Resultado es verdadero si solo una condición es verdadera
$$ bind, #, from ##, except ##, seek
textoCompleto = bind(texto1, "
" bind texto2); $$ Combina texto1 y texto2 con un espacio
Stack longitud = #(textoCompleto); $$ Longitud de textoCompleto
Spider subcadena = from textoCompleto ## 0 ## 5; $$ Subcadena de textoCompleto desde 0 hasta 5
Spider sinNotch = except textoCompleto ## 0 ## 6; $$ Elimina caracteres de 0 a 6 en textoCompleto
Stack posicion = seek(textoCompleto, "
Engine
"); $$ Posición de "
Engine
" en textoCompleto
$$ isEngraved, isInscribed, etchUp, etchDown
Torch esLetra = isEngraved(letra); $$ Verifica si letra es una letra
Torch esDigito = isInscribed(letra); $$ Verifica si letra es un dígito
letraMayuscula = etchUp(letra); $$ Convierte letra a mayúscula
Rune letraMinuscula = etchDown(letraMayuscula); $$ Convierte letraMayuscula a minúscula
$$ Operaciones de conjuntos
add(conjunto1, 4); $$ Añade 4 a conjunto1
drop(conjunto1, 2); $$ Elimina 2 de conjunto1
conjuntoResultado = feed(conjunto1, conjunto2); $$ Intersección de conjunto1 y conjunto2
resultado = map(conjunto1, 3); $$ Verifica si 3 está en conjunto1
Torch conjuntoVacio = void(conjunto1); $$ Verifica si conjunto1 está vacío
$$ Operaciones de archivos
unlock(archivo1); $$ Abre archivo1 para escritura
forge(archivo1, "
Texto
de
prueba
"); $$ Escribe "
Texto
de
prueba
" en archivo1
lock(archivo1); $$ Cierra archivo1
Book nuevoArchivo = make({/ "
nuevo
.
txt
", 'E' /}); $$ Crea nuevo archivo "
nuevo
.
txt
"
forge(nuevoArchivo, "
Contenido
del
nuevo
archivo
"); $$ Escribe en nuevoArchivo
lock(nuevoArchivo); $$ Cierra nuevoArchivo
unlock(archivo1); $$ Abre archivo1
unlock(nuevoArchivo); $$ Abre nuevoArchivo
expand(archivo1, nuevoArchivo); $$ Expande archivo1 con contenido de nuevoArchivo
lock(archivo1); $$ Cierra archivo1
lock(nuevoArchivo); $$ Cierra nuevoArchivo
$$ Operadores de flotantes
resultadoFlotante = flotante1 :+ flotante2; $$ Suma de flotante1 y flotante2
resultadoFlotante = flotante1 :- flotante2; $$ Resta de flotante1 y flotante2
resultadoFlotante = flotante1 :* flotante2; $$ Multiplicación de flotante1 y flotante2
resultadoFlotante = flotante1 :// flotante2; $$ División de flotante1 y flotante2
resultadoFlotante = flotante1 :% flotante2; $$ Módulo de flotante1 y flotante2
PolloAsado
}
worldSave
$*
Prueba_Lit_Enteros.ne
Propósito: Verificar reconocimiento de literales enteros (positivos, negativos, cero)
Probar: Stack
Fecha: 28/04/2025
*$
$$ Prueba de literales enteros en NotchEngine
$$ Verificando: enteros positivos, negativos y cero
WorldName PruebaLitEnteros:
Bedrock
$$ Constantes enteras
Obsidian Stack CERO 0;
Obsidian Stack POSITIVO 42;
Obsidian Stack NEGATIVO -42;
Obsidian Stack MAX_VALOR 2147483647; $$ Valor máximo de 32 bits
Obsidian Stack MIN_VALOR -2147483648; $$ Valor mínimo de 32 bits
Inventory
$$ Variables con literales enteros
Stack cero = 0;
Stack uno = 1;
Stack diez = 10;
Stack cien = 100;
Stack mil = 1000;
Stack millon = 1000000;
$$ Enteros negativos
Stack negUno = -1;
Stack negDiez = -10;
Stack negCien = -100;
Stack negMil = -1000;
Stack negMillon = -1000000;
$$ Valor entero máximo y mínimo (aproximadamente)
Stack maxInt = 2147483647;
Stack minInt = -2147483648;
$$ Variables para resultados
Stack resultado = 0;
SpawnPoint
PolloCrudo
$$ Operaciones aritméticas con literales enteros directos
resultado = 5 + 3; $$ 8
dropperSpider("
5
+
3
=
" bind resultado);
resultado = 10 - 7; $$ 3
dropperSpider("
10
-
7
=
" bind resultado);
resultado = 6 * 4; $$ 24
dropperSpider("
6
*
4
=
" bind resultado);
resultado = 20 // 4; $$ 5
dropperSpider("
20
4
=
" bind resultado);
resultado = 17 % 5; $$ 2
dropperSpider("
17
%
5
=
" bind resultado);
$$ Uso de literales enteros en expresiones complejas
resultado = (5 + 3) * 2 - 4 // 2; $$ 16 - 2 = 14
dropperSpider("
(
5
+
3
)
*
2
-
4
2
=
" bind resultado);
$$ Operaciones con literales enteros negativos
resultado = -5 + 10; $$ 5
dropperSpider("
-
5
+
10
=
" bind resultado);
resultado = 5 + -10; $$ -5
dropperSpider("
5
+
-
10
=
" bind resultado);
resultado = -5 * -4; $$ 20
dropperSpider("
-
5
*
-
4
=
" bind resultado);
$$ Uso de literales enteros en estructuras de control
walk i set 1 to 5 craft
PolloCrudo
dropperSpider("
Iteración
:
" bind i);
PolloAsado
$$ Comparaciones con literales enteros
target 10 > 5 craft hit
PolloCrudo
dropperSpider("
10
es
mayor
que
5
");
PolloAsado
target 0 is 0 craft hit
PolloCrudo
dropperSpider("
0
es
igual
a
0
");
PolloAsado
target -10 < -5 craft hit
PolloCrudo
dropperSpider("
-
10
es
menor
que
-
5
");
PolloAsado
$$ Operaciones con valores extremos (cuidado con overflow)
dropperSpider("
Valor
máximo
de
entero
:
" bind maxInt);
dropperSpider("
Valor
mínimo
de
entero
:
" bind minInt);
$$ Verificación del cero
target 0 is cero craft hit
PolloCrudo
dropperSpider("
Ambas
representaciones
de
cero
son
iguales
");
PolloAsado
PolloAsado
worldSave
$*
Prueba_Lit_Flotantes.ne
Propósito: Verificar reconocimiento de números flotantes (con parte decimal, sin parte decimal, negativos)
Probar: Ghast
Fecha: 28/04/2025
*$
$$ Prueba de literales flotantes en NotchEngine
$$ Verificando: flotantes con parte decimal, sin parte decimal, y negativos
WorldName PruebaLitFlotantes:
Bedrock
$$ Constantes flotantes
Obsidian Ghast CERO_PUNTO_CERO 0.0;
Obsidian Ghast PI 3.14159;
Obsidian Ghast E 2.71828;
Obsidian Ghast NEG_PI -3.14159;
Obsidian Ghast GRAVEDAD -9.8;
Inventory
$$ Flotantes positivos con parte decimal
Ghast decimal1 = 0.5;
Ghast decimal2 = 1.25;
Ghast decimal3 = 3.14159;
Ghast decimal4 = 2.71828;
Ghast decimal5 = 123.456;
$$ Flotantes negativos con parte decimal
Ghast negDecimal1 = -0.5;
Ghast negDecimal2 = -1.25;
Ghast negDecimal3 = -3.14159;
Ghast negDecimal4 = -2.71828;
Ghast negDecimal5 = -123.456;
$$ Formas alternativas (punto al principio, sin parte decimal)
Ghast decimal6 = .5; $$ Sin cero al principio, comienza con punto
Ghast decimal7 = 5.; $$ Sin decimales, termina con punto
$$ Números con muchos decimales
Ghast precisionAlta = 1.123456789012345;
$$ Números muy pequeños y muy grandes
Ghast muyPequeno = 0.0000001;
Ghast muyGrande = 1000000.0;
$$ Variables para resultados
Ghast resultado = 0.0;
SpawnPoint
PolloCrudo
$$ Operaciones aritméticas con literales flotantes directos
resultado = 5.5 :+ 3.5; $$ 9.0
dropperSpider("
5.5
:
+
3.5
=
");
dropperGhast(resultado);
resultado = 10.75 :- 7.25; $$ 3.5
dropperSpider("
10.75
:
-
7.25
=
");
dropperGhast(resultado);
resultado = 6.5 :* 2.0; $$ 13.0
dropperSpider("
6.5
:
*
2.0
=
");
dropperGhast(resultado);
resultado = 20.0 :// 4.0; $$ 5.0
dropperSpider("
20.0
:
4.0
=
");
dropperGhast(resultado);
resultado = 7.5 :% 2.0; $$ 1.5
dropperSpider("
7.5
:
%
2.0
=
");
dropperGhast(resultado);
$$ Uso de notaciones decimales alternativas
resultado = .5 :+ 2.; $$ 0.5 + 2.0 = 2.5
dropperSpider("
.
5
:
+
2
.
=
");
dropperGhast(resultado);
$$ Operaciones con literales flotantes negativos
resultado = -5.5 :+ 10.0; $$ 4.5
dropperSpider("
-
5.5
:
+
10.0
=
");
dropperGhast(resultado);
resultado = 5.0 :+ -10.0; $$ -5.0
dropperSpider("
5.0
:
+
-
10.0
=
");
dropperGhast(resultado);
resultado = -5.0 :* -4.0; $$ 20.0
dropperSpider("
-
5.0
:
*
-
4.0
=
");
dropperGhast(resultado);
$$ Expresiones complejas con flotantes
resultado = (2.5 :+ 1.5) :* 3.0 :- 5.0 :// 2.0; $$ 12.0 - 2.5 = 9.5
dropperSpider("
(
2.5
:
+
1.5
)
:
*
3.0
:
-
5.0
:
2.0
=
");
dropperGhast(resultado);
$$ Comparaciones con flotantes
target 3.14 > 3.0 craft hit
PolloCrudo
dropperSpider("
3.14
es
mayor
que
3.0
");
PolloAsado
target 0.1 :+ 0.2 isNot 0.3 craft hit $$ Debido a errores de precisión en flotantes
PolloCrudo
dropperSpider("
0.1
+
0.2
no
es
exactamente
igual
a
0.3
(
error
de
precisión
)
");
dropperGhast(0.1 :+ 0.2);
PolloAsado
$$ Conversión y coherción de tipos
Stack entero = 3.14159 >> Stack; $$ Cohersión a entero (trunca a 3)
dropperSpider("
PI
truncado
a
entero
:
" bind entero);
$$ Mostrar valores con diferentes precisiones
dropperSpider("
Valor
de
PI
:
");
dropperGhast(PI);
dropperSpider("
Número
con
alta
precisión
:
");
dropperGhast(precisionAlta);
dropperSpider("
Número
muy
pequeño
:
");
dropperGhast(muyPequeno);
dropperSpider("
Número
muy
grande
:
");
dropperGhast(muyGrande);
PolloAsado
worldSave
$*
Prueba_Lit_Caracteres.ne
Propósito: Verificar reconocimiento de caracteres (letras, dígitos, símbolos, escapes)
Probar: Rune, dropperRune, dropperSpider, dropperTorch
Fecha: 28/04/2025
*$
$$ Prueba de literales de caracteres en NotchEngine
$$ Verificando: letras, dígitos, símbolos y secuencias de escape
WorldName PruebaLitCaracteres:
Bedrock
$$ Constantes de caracteres
Obsidian Rune LETRA_A 'A';
Obsidian Rune LETRA_Z 'Z';
Obsidian Rune DIGITO_0 '0';
Obsidian Rune DIGITO_9 '9';
Obsidian Rune NUEVA_LINEA '\n';
Obsidian Rune TABULACION '\t';
Inventory
$$ Letras mayúsculas
Rune letraA = 'A';
Rune letraB = 'B';
Rune letraC = 'C';
Rune letraZ = 'Z';
$$ Letras minúsculas
Rune letraMina = 'a';
Rune letraMinb = 'b';
Rune letraMinc = 'c';
Rune letraMinz = 'z';
$$ Dígitos
Rune digito0 = '0';
Rune digito1 = '1';
Rune digito5 = '5';
Rune digito9 = '9';
$$ Símbolos comunes
Rune simboloExclamacion = '!';
Rune simboloInterrogacion = '?';
Rune simboloArroba = '@';
Rune simboloNumeral = '#';
Rune simboloDolar = '$';
Rune simboloPorcentaje = '%';
Rune simboloAmpersand = '&';
Rune simboloAsterisco = '*';
Rune simboloParentesisIzq = '(';
Rune simboloParentesisDer = ')';
Rune simboloGuion = '-';
Rune simboloGuionBajo = '_';
Rune simboloIgual = '=';
Rune simboloMas = '+';
Rune simboloCorcheteIzq = '[';
Rune simboloCorcheteDer = ']';
Rune simboloLlaveIzq = '{';
Rune simboloLlaveDer = '}';
Rune simboloPuntoyComa = ';';
Rune simboloDosPuntos = ':';
Rune simboloComillaSimple = '\'';
Rune simboloComillaDoble = '"
';
Rune simboloBarra = '
';
Rune simboloBarraInversa = '
';
Rune simboloBarraVertical = '
';
Rune simboloComa = '
,
';
Rune simboloPunto = '
.
';
Rune simboloMenorQue = '
<
';
Rune simboloMayorQue = '
>
';
$$ Secuencias de escape
Rune escapeNuevaLinea = '
n
';
Rune escapeTabulacion = '
t
';
Rune escapeRetornoCarro = '
r
';
Rune escapeBarraInversa = '
';
Rune escapeComillaSimple = '
''
;
Rune
escapeComillaDoble
=
'\"'
;
SpawnPoint
PolloCrudo
dropperSpider
(
"Letras mayúsculas: "
)
;
dropperRune
(
letraA
)
;
dropperRune
(
letraB
)
;
dropperRune
(
letraC
)
;
dropperSpider
(
"Letras minúsculas: "
)
;
dropperRune
(
letraMina
)
;
dropperRune
(
letraMinb
)
;
dropperRune
(
letraMinc
)
;
dropperSpider
(
"Dígitos: "
)
;
dropperRune
(
digito0
)
;
dropperRune
(
digito1
)
;
dropperRune
(
digito5
)
;
dropperRune
(
digito9
)
;
dropperSpider
(
"Símbolos: "
)
;
dropperRune
(
simboloExclamacion
)
;
dropperRune
(
simboloInterrogacion
)
;
dropperRune
(
simboloArroba
)
;
dropperRune
(
simboloNumeral
)
;
Spider
texto
=
"NotchEngine"
;
Rune
primerCaracter
=
texto
[
0
]
;
Rune
ultimoCaracter
=
texto
[
10
]
;
dropperSpider
(
"Primer carácter de 'NotchEngine': "
)
;
dropperRune
(
primerCaracter
)
;
dropperSpider
(
"Último carácter de 'NotchEngine': "
)
;
dropperRune
(
ultimoCaracter
)
;
Rune
letraMinuscula
=
'a'
;
Rune
letraMayuscula
=
etchUp
(
letraMinuscula
)
;
dropperSpider
(
"Minúscula: "
)
;
dropperRune
(
letraMinuscula
)
;
dropperSpider
(
"Convertida a mayúscula: "
)
;
dropperRune
(
letraMayuscula
)
;
letraMinuscula
=
etchDown
(
letraMayuscula
)
;
dropperSpider
(
"Convertida nuevamente a minúscula: "
)
;
dropperRune
(
letraMinuscula
)
;
Torch
esLetra
=
isEngraved
(
'A'
)
;
Torch
esDigito
=
isInscribed
(
'5'
)
;
dropperSpider
(
"¿'A' es una letra? "
)
;
dropperTorch
(
esLetra
)
;
dropperSpider
(
"¿'5' es un dígito? "
)
;
dropperTorch
(
esDigito
)
;
esLetra
=
isEngraved
(
'7'
)
;
esDigito
=
isInscribed
(
'K'
)
;
dropperSpider
(
"¿'7' es una letra? "
)
;
dropperTorch
(
esLetra
)
;
dropperSpider
(
"¿'K' es un dígito? "
)
;
dropperTorch
(
esDigito
)
;
Stack
valorAsciiA
=
letraA
>
>
Stack
;
dropperSpider
(
"Valor ASCII de 'A': "
bind
valorAsciiA
)
;
PolloAsado
worldSave
WorldName
PruebaLitStrings
:
Bedrock
Obsidian
Spider
VACIO
""
;
Obsidian
Spider
ESPACIO
" "
;
Obsidian
Spider
SALUDO
"Hola Mundo"
;
Obsidian
Spider
CON_COMILLAS
"Este string tiene \"comillas\""
;
Obsidian
Spider
MULTILINEA
"Primera línea\nSegunda línea"
;
Inventory
Spider
cadenaVacia
=
""
;
Spider
espacioSimple
=
" "
;
Spider
cadenaSimple
=
"Texto simple"
;
Spider
conNumeros
=
"Notch Engine v1.0"
;
Spider
conSimbolos
=
"¡Hola, mundo! ¿Cómo estás?"
;
Spider
conCaracteresEspeciales
=
"#$%&/()=?¡"
;
Spider
conNuevaLinea
=
"Primera línea\nSegunda línea"
;
Spider
conTabulacion
=
"Columna1\tColumna2\tColumna3"
;
Spider
conRetornoCarro
=
"Texto con\rretorno de carro"
;
Spider
conBarraInversa
=
"Ruta de archivo: C:\\Archivos\\datos.txt"
;
Spider
conComillasSimples
=
"Texto con 'comillas simples'"
;
Spider
conComillasDobles
=
"Texto con \"comillas dobles\""
;
Spider
mixto
=
"Abc123!@#\n\t\"'"
;
Spider
cadenaLarga
=
"Esta es una cadena de texto más larga que contiene múltiples palabras, números como 12345, y símbolos como $%&. Es útil para probar el manejo de cadenas extensas en el analizador léxico y asegurarse de que no hay limitaciones inesperadas en la longitud de las cadenas."
;
Spider
prefijo
=
"Notch"
;
Spider
sufijo
=
"Engine"
;
Spider
resultado
;
SpawnPoint
PolloCrudo
dropperSpider
(
"Cadena simple: "
bind
cadenaSimple
)
;
dropperSpider
(
"Cadena con números: "
bind
conNumeros
)
;
dropperSpider
(
"Cadena con símbolos: "
bind
conSimbolos
)
;
resultado
=
bind
(
prefijo
,
" "
bind
sufijo
)
;
dropperSpider
(
"Concatenación: "
bind
resultado
)
;
Stack
longitud
=
#
(
resultado
)
;
dropperSpider
(
"Longitud de '"
bind
resultado
bind
"': "
bind
longitud
)
;
Spider
subcadena
=
from
resultado
#
#
0
#
#
5
;
dropperSpider
(
"Subcadena (0, 5): "
bind
subcadena
)
;
Spider
sinNotch
=
except
resultado
#
#
0
#
#
6
;
dropperSpider
(
"Sin los primeros 6 caracteres: "
bind
sinNotch
)
;
Stack
posicion
=
seek
(
resultado
,
"Engine"
)
;
dropperSpider
(
"Posición de 'Engine': "
bind
posicion
)
;
Rune
primerCaracter
=
resultado
[
0
]
;
dropperSpider
(
"Primer carácter: "
)
;
dropperRune
(
primerCaracter
)
;
Rune
ultimoCaracter
=
resultado
[
11
]
;
dropperSpider
(
"Último carácter: "
)
;
dropperRune
(
ultimoCaracter
)
;
dropperSpider
(
"Cadena con nueva línea:"
)
;
dropperSpider
(
conNuevaLinea
)
;
dropperSpider
(
"Cadena con tabulaciones:"
)
;
dropperSpider
(
conTabulacion
)
;
dropperSpider
(
"Cadena con comillas dobles:"
)
;
dropperSpider
(
conComillasDobles
)
;
dropperSpider
(
"Cadena larga:"
)
;
dropperSpider
(
cadenaLarga
)
;
target
cadenaVacia
is
""
craft
hit
PolloCrudo
dropperSpider
(
"La cadena está vacía"
)
;
PolloAsado
target
SALUDO
is
"Hola Mundo"
craft
hit
PolloCrudo
dropperSpider
(
"Las cadenas son iguales"
)
;
PolloAsado
PolloAsado
worldSave
WorldName
PruebaLitArreglos
:
Bedrock
Inventory
Shelf
[
5
]
Stack
numerosSimples
=
[
1
,
2
,
3
,
4
,
5
]
;
Shelf
[
3
]
Stack
numerosNegativos
=
[
-
10
,
-
20
,
-
30
]
;
Shelf
[
4
]
Stack
numerosMixtos
=
[
-
2
,
0
,
2
,
4
]
;
Shelf
[
1
]
Stack
unicoElemento
=
[
42
]
;
Shelf
[
0
]
Stack
arregloVacio
=
[
]
;
Shelf
[
5
]
Rune
vocales
=
[
'a'
,
'e'
,
'i'
,
'o'
,
'u'
]
;
Shelf
[
5
]
Rune
simbolos
=
[
'!'
,
'@'
,
'#'
,
'$'
,
'%'
]
;
Shelf
[
3
]
Spider
nombres
=
[
"Steve"
,
"Alex"
,
"Herobrine"
]
;
Shelf
[
4
]
Spider
diasSemana
=
[
"Lunes"
,
"Martes"
,
"Miércoles"
,
"Jueves"
]
;
Shelf
[
4
]
Torch
flags
=
[
On
,
Off
,
On
,
On
]
;
Shelf
[
3
]
Ghast
decimales
=
[
3.14
,
2.71
,
1.618
]
;
Shelf
[
3
]
Shelf
[
3
]
Stack
matriz
=
[
[
1
,
2
,
3
]
,
[
4
,
5
,
6
]
,
[
7
,
8
,
9
]
]
;
Shelf
[
2
]
Shelf
[
2
]
Shelf
[
2
]
Stack
cubo
=
[
[
[
1
,
2
]
,
[
3
,
4
]
]
,
[
[
5
,
6
]
,
[
7
,
8
]
]
]
;
Stack
suma
=
0
;
Stack
elementoActual
=
0
;
SpawnPoint
PolloCrudo
elementoActual
=
numerosSimples
[
0
]
;
dropperSpider
(
"Primer elemento del arreglo: "
bind
elementoActual
)
;
elementoActual
=
numerosSimples
[
4
]
;
dropperSpider
(
"Último elemento del arreglo: "
bind
elementoActual
)
;
numerosSimples
[
2
]
=
30
;
dropperSpider
(
"Elemento modificado: "
bind
numerosSimples
[
2
]
)
;
suma
=
0
;
walk
i
set
0
to
4
craft
PolloCrudo
suma
+
=
numerosSimples
[
i
]
;
dropperSpider
(
"Elemento "
bind
i
bind
": "
bind
numerosSimples
[
i
]
)
;
PolloAsado
dropperSpider
(
"Suma de todos los elementos: "
bind
suma
)
;
dropperSpider
(
"Vocales: "
)
;
walk
i
set
0
to
4
craft
PolloCrudo
dropperRune
(
vocales
[
i
]
)
;
PolloAsado
dropperSpider
(
"Nombres: "
)
;
walk
i
set
0
to
2
craft
PolloCrudo
dropperSpider
(
nombres
[
i
]
)
;
PolloAsado
dropperSpider
(
"Flags: "
)
;
walk
i
set
0
to
3
craft
PolloCrudo
dropperTorch
(
flags
[
i
]
)
;
PolloAsado
dropperSpider
(
"Decimales: "
)
;
walk
i
set
0
to
2
craft
PolloCrudo
dropperGhast
(
decimales
[
i
]
)
;
PolloAsado
elementoActual
=
matriz
[
1
]
[
1
]
;
dropperSpider
(
"Elemento central de la matriz: "
bind
elementoActual
)
;
matriz
[
0
]
[
2
]
=
10
;
dropperSpider
(
"Elemento modificado de la matriz: "
bind
matriz
[
0
]
[
2
]
)
;
dropperSpider
(
"Matriz completa:"
)
;
walk
i
set
0
to
2
craft
PolloCrudo
walk
j
set
0
to
2
craft
PolloCrudo
dropperStack
(
matriz
[
i
]
[
j
]
)
;
PolloAsado
dropperSpider
(
""
)
;
PolloAsado
elementoActual
=
cubo
[
1
]
[
0
]
[
1
]
;
dropperSpider
(
"Elemento de cubo [1][0][1]: "
bind
elementoActual
)
;
Shelf
[
4
]
Stack
fibonacci
=
[
1
,
1
,
2
,
3
]
;
dropperSpider
(
"Fibonacci: "
)
;
walk
i
set
0
to
3
craft
PolloCrudo
dropperStack
(
fibonacci
[
i
]
)
;
PolloAsado
PolloAsado
worldSave
WorldName
PruebaLitRegistros
:
Inventory
Entity
Jugador
PolloCrudo
Spider
nombre
;
Stack
nivel
;
Ghast
salud
;
Torch
activo
;
PolloAsado
;
Entity
Coordenada
PolloCrudo
Stack
x
;
Stack
y
;
Stack
z
;
PolloAsado
;
Entity
Configuracion
PolloCrudo
Torch
modoDebug
;
Stack
volumen
;
Spider
idioma
;
PolloAsado
;
Entity
Jugador
steve
=
{
nombre
:
"Steve"
,
nivel
:
1
,
salud
:
20.0
,
activo
:
On
}
;
Entity
Jugador
alex
=
{
nombre
:
"Alex"
,
nivel
:
2
,
salud
:
18.5
,
activo
:
On
}
;
Entity
Coordenada
posicion
=
{
x
:
10
,
y
:
20
,
z
:
30
}
;
Entity
Configuracion
config
=
{
modoDebug
:
Off
,
volumen
:
75
,
idioma
:
"Español"
}
;
Entity
Jugador
jugadorVacio
=
{
}
;
Entity
Coordenada
origen
=
{
x
:
0
}
;
Entity
Coordenada
punto
=
{
x
:
5
+
5
,
y
:
10
*
2
,
z
:
100
2
}
;
SpawnPoint
PolloCrudo
dropperSpider
(
steve
@
nombre
)
;
dropperStack
(
posicion
@
x
)
;
dropperTorch
(
config
@
modoDebug
)
;
steve
@
nivel
=
5
;
posicion
@
z
=
50
;
Stack
nivelTotal
=
steve
@
nivel
+
alex
@
nivel
;
dropperStack
(
nivelTotal
)
;
wither
steve
craft
PolloCrudo
dropperSpider
(
"Nombre: "
bind
nombre
)
;
dropperStack
(
nivel
)
;
dropperGhast
(
salud
)
;
PolloAsado
Entity
Jugador
herobrine
=
{
nombre
:
"Herobrine"
,
nivel
:
100
,
salud
:
1000.0
,
activo
:
On
}
;
Entity
Coordenada
pos2
=
{
x
:
100
,
y
:
200
,
z
:
300
}
;
PolloAsado
worldSave
WorldName
PruebaLitConjuntos
:
Inventory
Chest
numeros
=
{
:
1
,
2
,
3
,
4
,
5
:
}
;
Chest
primos
=
{
:
2
,
3
,
5
,
7
,
11
,
13
,
17
,
19
:
}
;
Chest
pares
=
{
:
2
,
4
,
6
,
8
,
10
:
}
;
Chest
vocales
=
{
:
'a'
,
'e'
,
'i'
,
'o'
,
'u'
:
}
;
Chest
consonantes
=
{
:
'b'
,
'c'
,
'd'
,
'f'
,
'g'
:
}
;
Chest
nombres
=
{
:
"Steve"
,
"Alex"
,
"Herobrine"
,
"Notch"
:
}
;
Chest
herramientas
=
{
:
"Espada"
,
"Pico"
,
"Hacha"
,
"Pala"
:
}
;
Chest
vacio
=
{
:
:
}
;
Chest
singleton
=
{
:
42
:
}
;
Chest
mezcla
=
{
:
1
,
'a'
,
"texto"
:
}
;
Chest
calculados
=
{
:
1
+
1
,
2
*
2
,
10
2
:
}
;
Chest
booleanos
=
{
:
On
,
Off
:
}
;
SpawnPoint
PolloCrudo
add
(
numeros
,
6
)
;
dropperSpider
(
"Después de add(numeros, 6):"
)
;
drop
(
primos
,
2
)
;
dropperSpider
(
"Después de drop(primos, 2):"
)
;
Chest
union
=
feed
(
numeros
,
primos
)
;
dropperSpider
(
"Unión de numeros y primos:"
)
;
Chest
interseccion
=
map
(
numeros
,
pares
)
;
dropperSpider
(
"Intersección de numeros y pares:"
)
;
Torch
contiene
=
biom
(
vocales
,
'a'
)
;
dropperTorch
(
contiene
)
;
Torch
esVacio
=
void
(
vacio
)
;
dropperTorch
(
esVacio
)
;
Chest
conEspacios
=
{
:
'a'
,
'b'
,
'c'
:
}
;
Chest
conComentarios
=
{
:
1
,
2
,
3
:
}
;
Chest
{
:
1
,
'x'
,
"y"
:
}
;
PolloAsado
worldSave
WorldName
PruebaLitArchivos
:
Inventory
Book
archivoConfiguracion
=
{
"config.txt"
,
'L'
}
;
Book
archivoJugadores
=
{
"jugadores.dat"
,
'L'
}
;
Book
archivoNiveles
=
{
"niveles/nivel1.map"
,
'L'
}
;
Book
archivoLog
=
{
"sistema.log"
,
'E'
}
;
Book
archivoResultados
=
{
"resultados.txt"
,
'E'
}
;
Book
archivoExportacion
=
{
"export/datos.csv"
,
'E'
}
;
Book
archivoPuntajes
=
{
"puntajes.dat"
,
'A'
}
;
Book
archivoInventario
=
{
"inventario.sav"
,
'A'
}
;
Book
archivoEspecial
=
{
"archivo con espacios.txt"
,
'L'
}
;
Book
archivoEspecial2
=
{
"datos_especiales-2023.dat"
,
'E'
}
;
Book
archivoRutaRelativa
=
{
"../datos/config.ini"
,
'L'
}
;
Book
archivoRutaAbsoluta
=
{
"C:/Notch/Engine/data.bin"
,
'E'
}
;
Book
archivoTexto
=
{
"readme.txt"
,
'L'
}
;
Book
archivoImagen
=
{
"textura.png"
,
'L'
}
;
Book
archivoJSON
=
{
"settings.json"
,
'A'
}
;
Book
archivoXML
=
{
"estructura.xml"
,
'A'
}
;
Book
conBarras
=
{
"dir/subdir/archivo.ext"
,
'L'
}
;
Book
conPuntos
=
{
"../../archivo.ext"
,
'E'
}
;
Book
espaciado1
=
{
"compacto.txt"
,
'L'
}
;
Book
espaciado2
=
{
"espacios.txt"
,
'E'
}
;
Book
comentado
=
{
"log.txt"
,
'L'
}
;
SpawnPoint
PolloCrudo
unlock
(
archivoLog
)
;
forge
(
archivoLog
,
"Entrada de log: Inicio de programa"
)
;
lock
(
archivoLog
)
;
Book
nuevoArchivo
=
make
(
{
"nuevo.txt"
,
'E'
}
)
;
unlock
(
archivoConfiguracion
)
;
Spider
contenido
=
gather
(
archivoConfiguracion
)
;
lock
(
archivoConfiguracion
)
;
expand
(
archivoLog
,
archivoResultados
)
;
Book
{
"sinVariable.txt"
,
'A'
}
;
Book
arch1
=
{
"uno.txt"
,
'L'
}
;
Book
arch2
=
{
"dos.txt"
,
'E'
}
;
Book
conComentarioMedio
=
{
"comentado.txt"
,
'A'
}
;
PolloAsado
worldSave
WorldName
PruebaOpAritmeticos
:
Inventory
Stack
a
=
10
;
Stack
b
=
3
;
Stack
c
;
Stack
resultado
;
SpawnPoint
PolloCrudo
c
=
a
+
b
;
dropperSpider
(
"Suma: "
bind
c
)
;
c
=
a
-
b
;
dropperSpider
(
"Resta: "
bind
c
)
;
c
=
a
*
b
;
dropperSpider
(
"Multiplicación: "
bind
c
)
;
c
=
a
b
;
dropperSpider
(
"División entera: "
bind
c
)
;
c
=
a
%
b
;
dropperSpider
(
"Módulo: "
bind
c
)
;
resultado
=
a
+
b
*
c
;
dropperSpider
(
"a + b * c = "
bind
resultado
)
;
resultado
=
(
a
+
b
)
*
c
;
dropperSpider
(
"(a + b) * c = "
bind
resultado
)
;
resultado
=
a
+
b
+
c
;
dropperSpider
(
"a + b + c = "
bind
resultado
)
;
resultado
=
a
*
b
c
+
a
-
b
;
dropperSpider
(
"a * b // c + a - b = "
bind
resultado
)
;
resultado
=
-
a
;
dropperSpider
(
"-a = "
bind
resultado
)
;
resultado
=
5
+
3
;
dropperSpider
(
"5 + 3 = "
bind
resultado
)
;
resultado
=
-
(
a
+
b
)
;
dropperSpider
(
"-(a + b) = "
bind
resultado
)
;
resultado
=
a
+
b
;
resultado
=
a
-
b
;
resultado
=
a
*
b
;
resultado
=
a
b
;
resultado
=
a
%
b
;
resultado
=
a
+
b
;
resultado
=
a
-
b
;
resultado
=
a
*
b
;
resultado
=
a
b
;
resultado
=
a
%
b
;
resultado
=
a
+
b
;
resultado
=
a
*
b
;
resultado
=
(
(
(
(
a
+
b
)
*
c
)
2
)
%
10
)
;
soulsand
a
;
resultado
=
a
+
b
;
magma
b
;
resultado
=
a
-
b
;
PolloAsado
worldSave
WorldName
PruebaOpFlotantes
:
Inventory
Ghast
x
=
10.5
;
Ghast
y
=
3.25
;
Ghast
z
;
Ghast
resultado
;
SpawnPoint
PolloCrudo
z
=
x
:
+
y
;
dropperSpider
(
"Suma flotante: "
bind
z
)
;
z
=
x
:
-
y
;
dropperSpider
(
"Resta flotante: "
bind
z
)
;
z
=
x
:
*
y
;
dropperSpider
(
"Multiplicación flotante: "
bind
z
)
;
z
=
x
:
y
;
dropperSpider
(
"División flotante: "
bind
z
)
;
z
=
x
:
%
y
;
dropperSpider
(
"Módulo flotante: "
bind
z
)
;
resultado
=
x
:
+
y
:
*
z
;
dropperSpider
(
"x :+ y :* z = "
bind
resultado
)
;
resultado
=
(
x
:
+
y
)
:
*
z
;
dropperSpider
(
"(x :+ y) :* z = "
bind
resultado
)
;
resultado
=
x
:
+
y
:
+
z
;
dropperSpider
(
"x :+ y :+ z = "
bind
resultado
)
;
resultado
=
x
:
*
y
:
z
:
+
x
:
-
y
;
dropperSpider
(
"x :* y :// z :+ x :- y = "
bind
resultado
)
;
resultado
=
-
x
;
dropperSpider
(
"-x = "
bind
resultado
)
;
resultado
=
5.5
:
+
3.2
;
dropperSpider
(
"5.5 :+ 3.2 = "
bind
resultado
)
;
resultado
=
-
(
x
:
+
y
)
;
dropperSpider
(
"-(x :+ y) = "
bind
resultado
)
;
resultado
=
x
:
+
y
;
resultado
=
x
:
-
y
;
resultado
=
x
:
*
y
;
resultado
=
x
:
y
;
resultado
=
x
:
%
y
;
resultado
=
x
:
+
y
;
resultado
=
x
:
-
y
;
resultado
=
x
:
*
y
;
resultado
=
x
:
y
;
resultado
=
x
:
%
y
;
resultado
=
x
:
+
y
;
resultado
=
x
:
*
y
;
resultado
=
(
(
(
(
x
:
+
y
)
:
*
z
)
:
2.0
)
:
%
10.0
)
;
Ghast
mezcla1
=
x
:
+
5
;
Ghast
mezcla2
=
3.5
:
*
y
;
Ghast
mezcla3
=
x
:
+
(
y
:
*
2.0
)
:
1.5
;
Spider
texto
=
"Notch:Engine"
;
Stack
entero
=
(
x
:
+
y
)
>
>
Stack
;
PolloAsado
worldSave
WorldName
PruebaOpComparacion
:
Inventory
Stack
a
=
10
;
Stack
b
=
5
;
Torch
resultado
;
Ghast
x
=
3.5
;
Ghast
y
=
2.75
;
Spider
cadena1
=
"abc"
;
Spider
cadena2
=
"def"
;
Rune
char1
=
'A'
;
Rune
char2
=
'B'
;
Torch
bool1
=
On
;
Torch
bool2
=
Off
;
SpawnPoint
PolloCrudo
resultado
=
a
<
b
;
dropperSpider
(
"a < b: "
bind
resultado
)
;
resultado
=
x
<
y
;
dropperSpider
(
"x < y: "
bind
resultado
)
;
resultado
=
cadena1
<
cadena2
;
dropperSpider
(
"cadena1 < cadena2: "
bind
resultado
)
;
resultado
=
char1
<
char2
;
dropperSpider
(
"char1 < char2: "
bind
resultado
)
;
resultado
=
a
>
b
;
dropperSpider
(
"a > b: "
bind
resultado
)
;
resultado
=
x
>
y
;
dropperSpider
(
"x > y: "
bind
resultado
)
;
resultado
=
a
<=
b
;
dropperSpider
(
"a <= b: "
bind
resultado
)
;
resultado
=
x
<=
y
;
dropperSpider
(
"x <= y: "
bind
resultado
)
;
resultado
=
a
>=
b
;
dropperSpider
(
"a >= b: "
bind
resultado
)
;
resultado
=
x
>=
y
;
dropperSpider
(
"x >= y: "
bind
resultado
)
;
resultado
=
a
is
b
;
dropperSpider
(
"a is b: "
bind
resultado
)
;
resultado
=
x
is
y
;
dropperSpider
(
"x is y: "
bind
resultado
)
;
resultado
=
cadena1
is
cadena2
;
dropperSpider
(
"cadena1 is cadena2: "
bind
resultado
)
;
resultado
=
bool1
is
bool2
;
dropperSpider
(
"bool1 is bool2: "
bind
resultado
)
;
resultado
=
a
isNot
b
;
dropperSpider
(
"a isNot b: "
bind
resultado
)
;
resultado
=
x
isNot
y
;
dropperSpider
(
"x isNot y: "
bind
resultado
)
;
resultado
=
cadena1
isNot
cadena2
;
dropperSpider
(
"cadena1 isNot cadena2: "
bind
resultado
)
;
resultado
=
bool1
isNot
bool2
;
dropperSpider
(
"bool1 isNot bool2: "
bind
resultado
)
;
resultado
=
a
<
b
;
resultado
=
a
>
b
;
resultado
=
a
<=
b
;
resultado
=
a
>=
b
;
resultado
=
aisb
;
resultado
=
a
is
b
;
resultado
=
aisNotb
;
resultado
=
a
isNot
b
;
resultado
=
a
<
b
;
resultado
=
a
>
b
;
resultado
=
a
<=
b
;
resultado
=
a
>=
b
;
resultado
=
a
is
b
;
resultado
=
a
isNot
b
;
target
a
<
b
craft
hit
PolloCrudo
dropperSpider
(
"a es menor que b"
)
;
PolloAsado
repeater
x
>
y
craft
PolloCrudo
dropperSpider
(
"x es mayor que y"
)
;
PolloAsado
resultado
=
(
a
+
b
)
>
(
x
:
+
y
)
;
resultado
=
a
*
2
<=
b
*
3
;
resultado
=
(
a
2
)
is
(
b
1
)
;
resultado
=
bind
(
cadena1
,
cadena2
)
isNot
"abcdef"
;
Spider
islandia
=
"país"
;
Stack
isNotacion
=
42
;
PolloAsado
worldSave
WorldName
PruebaOpAsignacion
:
Inventory
Stack
contador
=
10
;
Stack
acumulador
=
0
;
Ghast
decimal
=
5.5
;
Spider
texto
=
"Notch"
;
Shelf
[
5
]
Stack
arreglo
;
Entity
Punto
PolloCrudo
Stack
x
;
Stack
y
;
PolloAsado
;
Entity
Punto
punto
;
SpawnPoint
PolloCrudo
contador
=
5
;
dropperSpider
(
"Asignación simple: "
bind
contador
)
;
decimal
=
3.14
;
texto
=
"Engine"
;
contador
+
=
3
;
dropperSpider
(
"Asignación con suma: "
bind
contador
)
;
acumulador
=
0
;
acumulador
+
=
contador
;
acumulador
+
=
2
;
dropperSpider
(
"Acumulador después de += : "
bind
acumulador
)
;
contador
-
=
2
;
dropperSpider
(
"Asignación con resta: "
bind
contador
)
;
acumulador
=
20
;
acumulador
-
=
5
;
acumulador
-
=
contador
;
dropperSpider
(
"Acumulador después de -= : "
bind
acumulador
)
;
contador
*
=
3
;
dropperSpider
(
"Asignación con multiplicación: "
bind
contador
)
;
acumulador
=
2
;
acumulador
*
=
contador
;
dropperSpider
(
"Acumulador después de *= : "
bind
acumulador
)
;
contador
=
2
;
dropperSpider
(
"Asignación con división: "
bind
contador
)
;
acumulador
=
50
;
acumulador
=
5
;
dropperSpider
(
"Acumulador después de /= : "
bind
acumulador
)
;
contador
%
=
3
;
dropperSpider
(
"Asignación con módulo: "
bind
contador
)
;
acumulador
=
17
;
acumulador
%
=
5
;
dropperSpider
(
"Acumulador después de %= : "
bind
acumulador
)
;
arreglo
[
0
]
=
10
;
arreglo
[
1
]
=
20
;
arreglo
[
2
]
=
30
;
arreglo
[
0
]
+
=
5
;
dropperSpider
(
"arreglo[0] después de += : "
bind
arreglo
[
0
]
)
;
arreglo
[
1
]
-
=
5
;
dropperSpider
(
"arreglo[1] después de -= : "
bind
arreglo
[
1
]
)
;
arreglo
[
2
]
*
=
2
;
dropperSpider
(
"arreglo[2] después de *= : "
bind
arreglo
[
2
]
)
;
punto
@
x
=
10
;
punto
@
y
=
20
;
punto
@
x
+
=
5
;
dropperSpider
(
"punto@x después de += : "
bind
punto
@
x
)
;
punto
@
y
-
=
8
;
dropperSpider
(
"punto@y después de -= : "
bind
punto
@
y
)
;
contador
=
5
;
contador
+
=
3
;
contador
-
=
2
;
contador
*
=
4
;
contador
=
2
;
contador
%
=
3
;
contador
=
5
;
contador
+
=
3
;
contador
-
=
2
;
contador
*
=
4
;
contador
=
2
;
contador
%
=
3
;
contador
=
10
;
contador
+
=
5
;
Stack
a
=
1
,
b
=
2
,
c
=
3
;
contador
=
(
a
+
b
)
*
c
;
contador
+
=
a
*
b
;
contador
-
=
a
+
b
;
contador
*
=
(
a
*
2
)
+
(
b
*
3
)
;
contador
=
a
+
1
;
contador
%
=
b
*
2
;
a
=
10
;
b
=
20
;
c
=
30
;
Spider
igual_texto
=
"Este texto tiene un signo = dentro"
;
Spider
mas_texto
=
"Este texto tiene un signo + dentro"
;
Spider
menos_texto
=
"Este texto tiene un signo - dentro"
;
Spider
por_texto
=
"Este texto tiene un signo * dentro"
;
Spider
div_texto
=
"Este texto tiene un signo / dentro"
;
Spider
mod_texto
=
"Este texto tiene un signo % dentro"
;
PolloAsado
worldSave
WorldName
PruebaOpAcceso
:
Inventory
Shelf
[
5
]
Stack
numeros
;
Shelf
[
3
]
Shelf
[
3
]
matriz
;
Shelf
[
2
]
Shelf
[
2
]
Shelf
[
2
]
cubo
;
Spider
texto
=
"Notch Engine"
;
Entity
Punto
PolloCrudo
Stack
x
;
Stack
y
;
Stack
z
;
PolloAsado
;
Entity
Punto
punto
;
Entity
Persona
PolloCrudo
Spider
nombre
;
Stack
edad
;
Torch
activo
;
Shelf
[
3
]
Stack
notas
;
PolloAsado
;
Entity
Persona
estudiante
;
Shelf
[
3
]
Entity
Punto
puntos
;
Entity
Contenedor
PolloCrudo
Shelf
[
5
]
Stack
valores
;
Spider
etiqueta
;
PolloAsado
;
Entity
Contenedor
caja
;
SpawnPoint
PolloCrudo
numeros
[
0
]
=
10
;
numeros
[
1
]
=
20
;
numeros
[
2
]
=
30
;
Stack
valor
=
numeros
[
0
]
;
dropperSpider
(
"Valor en numeros[0]: "
bind
valor
)
;
Stack
indice
=
2
;
valor
=
numeros
[
indice
]
;
dropperSpider
(
"Valor en numeros[indice]: "
bind
valor
)
;
valor
=
numeros
[
1
+
1
]
;
dropperSpider
(
"Valor en numeros[1 + 1]: "
bind
valor
)
;
matriz
[
0
]
[
0
]
=
11
;
matriz
[
0
]
[
1
]
=
12
;
matriz
[
1
]
[
0
]
=
21
;
matriz
[
1
]
[
1
]
=
22
;
valor
=
matriz
[
1
]
[
1
]
;
dropperSpider
(
"Valor en matriz[1][1]: "
bind
valor
)
;
valor
=
matriz
[
indice
-
1
]
[
indice
-
1
]
;
dropperSpider
(
"Valor en matriz[indice - 1][indice - 1]: "
bind
valor
)
;
cubo
[
0
]
[
0
]
[
0
]
=
111
;
cubo
[
1
]
[
1
]
[
1
]
=
222
;
valor
=
cubo
[
1
]
[
1
]
[
1
]
;
dropperSpider
(
"Valor en cubo[1][1][1]: "
bind
valor
)
;
Rune
caracter
=
texto
[
0
]
;
dropperSpider
(
"Carácter en texto[0]: "
bind
caracter
)
;
caracter
=
texto
[
6
]
;
dropperSpider
(
"Carácter en texto[6]: "
bind
caracter
)
;
caracter
=
texto
[
indice
*
2
]
;
dropperSpider
(
"Carácter en texto[indice * 2]: "
bind
caracter
)
;
texto
[
0
]
=
'n'
;
dropperSpider
(
"Texto modificado: "
bind
texto
)
;
punto
@
x
=
10
;
punto
@
y
=
20
;
punto
@
z
=
30
;
valor
=
punto
@
x
;
dropperSpider
(
"Valor en punto@x: "
bind
valor
)
;
punto
@
y
=
punto
@
x
*
2
;
dropperSpider
(
"Valor en punto@y después de asignación: "
bind
punto
@
y
)
;
estudiante
@
nombre
=
"Steve"
;
estudiante
@
edad
=
25
;
estudiante
@
activo
=
On
;
estudiante
@
notas
[
0
]
=
85
;
estudiante
@
notas
[
1
]
=
90
;
estudiante
@
notas
[
2
]
=
95
;
Spider
nombre
=
estudiante
@
nombre
;
dropperSpider
(
"Nombre del estudiante: "
bind
nombre
)
;
Stack
nota
=
estudiante
@
notas
[
1
]
;
dropperSpider
(
"Segunda nota del estudiante: "
bind
nota
)
;
puntos
[
0
]
@
x
=
1
;
puntos
[
0
]
@
y
=
2
;
puntos
[
0
]
@
z
=
3
;
puntos
[
1
]
@
x
=
4
;
puntos
[
1
]
@
y
=
5
;
puntos
[
1
]
@
z
=
6
;
valor
=
puntos
[
1
]
@
y
;
dropperSpider
(
"Valor en puntos[1]@y: "
bind
valor
)
;
caja
@
etiqueta
=
"Items"
;
caja
@
valores
[
0
]
=
100
;
caja
@
valores
[
1
]
=
200
;
valor
=
caja
@
valores
[
1
]
;
dropperSpider
(
"Valor en caja@valores[1]: "
bind
valor
)
;
valor
=
numeros
[
0
]
;
nombre
=
estudiante
@
nombre
;
valor
=
numeros
[
0
]
;
valor
=
matriz
[
1
]
[
1
]
;
nombre
=
estudiante
@
nombre
;
valor
=
cubo
[
0
]
[
matriz
[
0
]
[
0
]
%
3
]
[
numeros
[
0
]
10
]
;
valor
=
numeros
[
0
]
;
nombre
=
estudiante
@
nombre
;
Spider
textoCuadrado
=
"Esto no es un [acceso]"
;
Spider
textoArroba
=
"Email: usuario@dominio.com"
;
PolloAsado
worldSave
WorldName
PruebaOpEspeciales
:
Bedrock
Obsidian
Stack
MAX_SIZE
1024
;
Inventory
Stack
entero
=
42
;
Ghast
flotante
=
3.14159
;
Spider
texto
=
"Notch Engine"
;
Rune
caracter
=
'A'
;
Torch
booleano
=
On
;
Shelf
[
5
]
Stack
arreglo
;
Chest
conjunto
=
{
:
1
,
2
,
3
:
}
;
Entity
Punto
PolloCrudo
Stack
x
;
Stack
y
;
PolloAsado
;
Entity
Punto
punto
;
SpawnPoint
PolloCrudo
Stack
tamanoStack
=
chunk
Stack
;
Stack
tamanoGhast
=
chunk
Ghast
;
Stack
tamanoSpider
=
chunk
Spider
;
Stack
tamanoRune
=
chunk
Rune
;
Stack
tamanoTorch
=
chunk
Torch
;
dropperSpider
(
"Tamaño de Stack en bytes: "
bind
tamanoStack
)
;
dropperSpider
(
"Tamaño de Ghast en bytes: "
bind
tamanoGhast
)
;
dropperSpider
(
"Tamaño de Spider en bytes: "
bind
tamanoSpider
)
;
dropperSpider
(
"Tamaño de Rune en bytes: "
bind
tamanoRune
)
;
dropperSpider
(
"Tamaño de Torch en bytes: "
bind
tamanoTorch
)
;
Stack
tamanoShelf
=
chunk
Shelf
[
5
]
Stack
;
Stack
tamanoChest
=
chunk
Chest
;
Stack
tamanoPunto
=
chunk
Punto
;
dropperSpider
(
"Tamaño de arreglo en bytes: "
bind
tamanoShelf
)
;
dropperSpider
(
"Tamaño de conjunto en bytes: "
bind
tamanoChest
)
;
dropperSpider
(
"Tamaño de Punto en bytes: "
bind
tamanoPunto
)
;
Stack
tamanoVariable
=
chunk
entero
;
Stack
tamanoArreglo
=
chunk
arreglo
;
Stack
tamanoTexto
=
chunk
texto
;
dropperSpider
(
"Tamaño de variable entero en bytes: "
bind
tamanoVariable
)
;
dropperSpider
(
"Tamaño de variable arreglo en bytes: "
bind
tamanoArreglo
)
;
dropperSpider
(
"Tamaño de variable texto en bytes: "
bind
tamanoTexto
)
;
Stack
tamanoExpresion
=
chunk
(
entero
*
2
+
10
)
;
dropperSpider
(
"Tamaño de expresión en bytes: "
bind
tamanoExpresion
)
;
Stack
enteroDeFlotante
=
flotante
>
>
Stack
;
dropperSpider
(
"Flotante convertido a entero: "
bind
enteroDeFlotante
)
;
Torch
booleanoDeEntero
=
entero
>
>
Torch
;
dropperSpider
(
"Entero convertido a booleano: "
bind
booleanoDeEntero
)
;
Rune
caracterDeTexto
=
texto
>
>
Rune
;
dropperSpider
(
"Primer carácter del texto: "
bind
caracterDeTexto
)
;
Stack
resultadoEntero
=
(
flotante
:
+
2.5
)
>
>
Stack
;
dropperSpider
(
"Suma flotante convertida a entero: "
bind
resultadoEntero
)
;
Stack
tam1
=
chunkStack
;
Stack
tam2
=
chunk
Stack
;
Stack
tam3
=
chunk
(
Stack
)
;
Stack
ent1
=
flotante
>
>
Stack
;
Stack
ent2
=
flotante
>
>
Stack
;
Stack
tam4
=
chunk
Stack
;
Stack
ent3
=
flotante
>
>
Stack
;
Stack
tam5
=
chunk
Stack
;
Stack
ent4
=
flotante
>
>
Stack
;
Stack
tamCombinado
=
chunk
(
flotante
>
>
Stack
)
;
Spider
textoMayor
=
"Esto no es una coherción >>"
;
Spider
textoChunk
=
"La palabra chunk no es un operador aquí"
;
Stack
resultado
=
(
flotante
:
*
2.0
>
>
Stack
)
+
(
entero
*
3
)
;
target
(
flotante
>
>
Stack
)
>
3
craft
hit
PolloCrudo
dropperSpider
(
"La parte entera de flotante es mayor que 3"
)
;
PolloAsado
PolloAsado
worldSave
WorldName
PruebaComLinea
:
Bedrock
Obsidian
Stack
MAX_LEVEL
100
;
Obsidian
Spider
VERSION
"1.0"
;
Inventory
Stack
contador
=
0
;
Spider
texto
=
"Notch Engine"
;
Rune
inicial
;
Stack
a
=
10
,
b
=
20
;
Recipe
Spell
calcular
(
Stack
::
a
,
b
)
->
Stack
;
CraftingTable
Spell
calcular
(
Stack
::
a
,
b
)
->
Stack
PolloCrudo
Stack
resultado
=
a
+
b
;
respawn
resultado
;
PolloAsado
Ritual
mostrarMensaje
(
Spider
::
mensaje
)
PolloCrudo
dropperSpider
(
mensaje
)
;
PolloAsado
SpawnPoint
PolloCrudo
contador
=
5
;
target
contador
>
0
craft
hit
PolloCrudo
dropperSpider
(
"Contador positivo"
)
;
PolloAsado
Stack
resultado
=
contador
+
10
;
Stack
suma
=
calcular
(
5
,
10
)
;
;
PolloAsado
worldSave
WorldName
PruebaComBloque
:
Bedrock
Obsidian
Stack
MAX_LEVEL
100
;
Obsidian
Spider
VERSION
"1.0"
;
Inventory
Stack
contador
=
0
;
Spider
texto
=
"Notch Engine"
;
Rune
inicial
;
Stack
a
=
10
,
b
=
20
;
Recipe
Spell
calcular
(
Stack
::
a
,
b
)
->
Stack
;
CraftingTable
Spell
calcular
(
Stack
::
a
,
b
)
->
Stack
PolloCrudo
Stack
resultado
=
a
+
b
;
respawn
resultado
;
PolloAsado
Ritual
mostrarMensaje
(
Spider
::
mensaje
)
PolloCrudo
dropperSpider
(
mensaje
)
;
PolloAsado
SpawnPoint
PolloCrudo
contador
=
5
+
10
;
target
contador
>
0
craft
hit
PolloCrudo
dropperSpider
(
"Contador positivo"
)
;
PolloAsado
dentro
pero
sin
cerrar
aún
*
secuencias
*
PolloAsado
worldSave
WorldName
PruebaComentarios
:
Inventory
Stack
contador
=
10
;
Spider
texto
=
"Comentario /* falso */ dentro de un string"
;
Rune
caracter
=
'*'
;
SpawnPoint
PolloCrudo
dropperSpider
(
"Los comentarios son importantes"
)
;
PolloAsado
worldSave
WorldName
PruebaIdentificadoresSimples
:
Bedrock
Obsidian
Stack
MAX
100
;
Obsidian
Spider
TITULO
"Notch Engine"
;
Inventory
Stack
a
;
Stack
contador
;
Stack
nivel
;
Stack
x
;
Stack
y
;
Stack
z
;
Stack
posicion
;
Stack
altura
;
Stack
ancho
;
Spider
nombre
;
Spider
texto
;
Spider
mensaje
;
Spider
saludo
;
Torch
activo
;
Torch
visible
;
Torch
terminado
;
Rune
inicial
;
Rune
caracter
;
Rune
simbolo
;
Ghast
pi
;
Ghast
temperatura
;
Ghast
velocidad
;
Stack
Contador
;
Spider
Nombre
;
Torch
Activo
;
Stack
i
;
Stack
j
;
Stack
k
;
Rune
c
;
Spider
s
;
Torch
b
;
Ghast
f
;
CraftingTable
Spell
suma
(
Stack
::
a
,
b
)
->
Stack
PolloCrudo
Stack
resultado
;
resultado
=
a
+
b
;
respawn
resultado
;
PolloAsado
Ritual
imprimir
(
Spider
::
mensaje
)
PolloCrudo
dropperSpider
(
mensaje
)
;
PolloAsado
SpawnPoint
PolloCrudo
Stack
valor
;
Stack
resultado
;
Spider
mensaje
;
valor
=
10
;
mensaje
=
"Hola"
;
resultado
=
valor
+
5
;
valor
=
suma
(
valor
,
20
)
;
ender_pearl
imprimir
(
mensaje
)
;
PolloAsado
worldSave
WorldName
PruebaIdentificadoresComplejos
:
Bedrock
Obsidian
Stack
MAX_LEVEL
100
;
Obsidian
Stack
MIN_LEVEL
1
;
Obsidian
Spider
GAME_TITLE
"Notch Engine"
;
Obsidian
Spider
VERSION_1_0
"v1.0"
;
Inventory
Stack
player_level
;
Stack
enemy_count
;
Stack
max_health
;
Stack
min_damage
;
Stack
current_position_x
;
Stack
counter1
;
Stack
item2
;
Stack
level3d
;
Stack
position2d
;
Stack
player1_health
;
Stack
item_1
;
Stack
player_2_score
;
Stack
enemy_level_3
;
Stack
position_x_1
;
Stack
inventory_slot_5
;
Stack
_temp
;
Stack
_internal_counter
;
Stack
_system_value
;
Stack
_player_data
;
Stack
very_long_variable_name_with_many_words
;
Spider
extremely_long_message_text_that_describes_something_in_detail
;
Torch
is_player_currently_in_creative_mode_with_flight_enabled
;
Stack
player5_current_health_max_100
;
Stack
enemy_3d_position_coordinate_x_12
;
Rune
player_initial_1
;
Spider
user_5_name
;
CraftingTable
Spell
calculate_total_damage
(
Stack
::
base_damage
,
critical_multiplier
;
Torch
::
is_headshot
)
->
Stack
PolloCrudo
Stack
total_damage
;
total_damage
=
base_damage
*
critical_multiplier
;
target
is_headshot
craft
hit
PolloCrudo
total_damage
=
total_damage
*
2
;
PolloAsado
respawn
total_damage
;
PolloAsado
Ritual
display_player_stats
(
Spider
::
player_name
;
Stack
level_1
,
health_points_100
)
PolloCrudo
dropperSpider
(
"Player: "
bind
player_name
)
;
dropperSpider
(
"Level: "
bind
level_1
)
;
dropperSpider
(
"Health: "
bind
health_points_100
)
;
PolloAsado
SpawnPoint
PolloCrudo
Stack
player1_health
=
100
;
Stack
enemy_count_5
=
10
;
Spider
main_player_name
=
"Steve_123"
;
player1_health
=
player1_health
-
20
;
enemy_count_5
=
calculate_total_damage
(
10
,
2
,
On
)
;
ender_pearl
display_player_stats
(
main_player_name
,
5
,
player1_health
)
;
Stack
___special_value
=
42
;
dropperStack
(
___special_value
)
;
PolloAsado
worldSave
WorldName
PruebaIdentificadoresSimilares
:
Bedrock
Obsidian
Stack
WorldNameTest
100
;
Obsidian
Spider
BedrockType
"Hard Stone"
;
Obsidian
Torch
InventoryFull
On
;
Inventory
Stack
worldname
;
Stack
WorldName2
;
Stack
bedrock
;
Stack
Bedrock_Type
;
Stack
inventory
;
Stack
InventorySlot
;
Stack
recipe
;
Stack
RecipeBook
;
Stack
craftingtable
;
Stack
CraftingTable2
;
Stack
spawnpoint
;
Stack
SpawnPoint_Main
;
Stack
stack
;
Spider
spider
;
Torch
torch
;
Rune
rune
;
Ghast
ghast
;
Chest
chest
;
Book
book
;
Stack
pollocrudo
;
Stack
PolloAsado
;
Stack
polloAsadoExtra
;
Stack
repeater
;
Stack
target
;
Stack
hit
;
Stack
miss
;
Stack
craft
;
Stack
jukebox
;
Stack
disc
;
Stack
silence
;
Stack
spawner
;
Stack
exhausted
;
Stack
walk
;
Stack
set
;
Stack
to
;
Stack
step
;
Stack
wither
;
Stack
creeper
;
Stack
enderPearl
;
Stack
enderpearlitem
;
Stack
ragequit
;
Stack
spell
;
Stack
Spell_Cast
;
Stack
ritual
;
Stack
RitualCeremony
;
Stack
respawn
;
Stack
respawnPoint
;
Stack
ender_pearl
;
Stack
enderpearlTeleport
;
Stack
soulsand
;
Stack
SoulSandBlock
;
Stack
magma
;
Stack
MagmaBlock
;
Stack
and
;
Stack
andOperator
;
Stack
or
;
Stack
orGate
;
Stack
not
;
Stack
notOperator
;
Stack
xor
;
Stack
xorCalculation
;
Stack
is
;
Stack
isNot
;
Stack
isEqual
;
Torch
on
;
Torch
onSwitch
;
Torch
off
;
Torch
offState
;
Stack
hopper
;
Stack
hopperMinecart
;
Stack
dropper
;
Stack
dropperFunction
;
CraftingTable
Spell
worldNameGenerator
(
)
->
Spider
PolloCrudo
Spider
spawnpoint
=
"DefaultSpawn"
;
Stack
craft
=
10
;
Spider
ritual
=
"Magic"
;
respawn
"Generated"
;
PolloAsado
Ritual
craftingTableMaker
(
Spider
::
recipe
;
Stack
inventory
)
PolloCrudo
Stack
spell
=
20
;
Stack
worldname
=
30
;
Torch
on
=
Off
;
dropperSpider
(
"Crafting table ready"
)
;
PolloAsado
SpawnPoint
PolloCrudo
Stack
worldname
=
1
;
Stack
bedrock
=
2
;
Stack
inventory
=
3
;
Stack
recipe
=
4
;
Stack
craftingtable
=
5
;
Stack
spawnpoint
=
6
;
worldname
=
worldname
+
bedrock
;
inventory
=
craftingtable
*
spawnpoint
;
target
worldname
>
recipe
craft
hit
PolloCrudo
Spider
spell
=
"Magic"
;
dropperSpider
(
spell
)
;
PolloAsado
Spider
generatedName
=
worldNameGenerator
(
)
;
ender_pearl
craftingTableMaker
(
"New Recipe"
,
inventory
)
;
PolloAsado
worldSave
WorldName
PruebaStringsLargos
:
Inventory
Spider
string_normal
=
"Este es un string normal"
;
Spider
string_largo
=
"Este es un string extremadamente largo para probar cómo maneja el analizador léxico los tokens de gran tamaño. El propósito es verificar si el buffer del analizador puede manejar correctamente cadenas que exceden el tamaño típico. En Minecraft, los jugadores pueden construir estructuras enormes y elaboradas, similar a cómo este string se extiende más allá de los límites normales. Las cadenas largas son útiles para almacenar textos extensos como descripciones, historias, o mensajes de diálogo en juegos. Este string sigue creciendo para asegurar que supere los límites habituales de procesamiento del analizador léxico."
;
Spider
string_muy_largo
=
"Este string es aún más largo que el anterior, llegando a aproximadamente mil caracteres para poner realmente a prueba los límites del analizador léxico. En el desarrollo de compiladores, es importante verificar cómo responde el sistema ante casos extremos. Los buffers mal dimensionados podrían causar desbordamientos o truncamientos inesperados. En el mundo de Minecraft, esto sería comparable a construir una megaestructura que se extiende hasta los límites permitidos del mundo. Es crucial que el compilador maneje correctamente estos casos límite, ya que en aplicaciones reales, los usuarios pueden introducir textos extremadamente largos, como documentación, logs detallados, o incluso código generado automáticamente. Este string continúa creciendo, añadiendo más y más caracteres para asegurar que pruebe adecuadamente la capacidad del buffer del analizador léxico. Una implementación robusta debería ser capaz de manejar este token sin problemas, reconociéndolo correctamente como un único string literal, sin importar su longitud. El tamaño máximo debería estar limitado únicamente por la memoria disponible en el sistema, no por limitaciones arbitrarias en el diseño del analizador léxico. Este string sigue y sigue, añadiendo más palabras y caracteres, para garantizar que realmente ponga a prueba los límites del analizador."
;
Spider
string_con_escapes
=
"Este string incluye secuencias de escape como: \n nueva línea, \t tabulación, \" comillas dobles, \\ barra invertida, y otros caracteres especiales como !@#$%^&*()_+-={}[]|:;<>,.?/~`"
;
Spider
string_multilinea
=
"Línea 1\nLínea 2\nLínea 3\nLínea 4\nLínea 5\nLínea 6\nLínea 7\nLínea 8\nLínea 9\nLínea 10\nLínea 11\nLínea 12\nLínea 13\nLínea 14\nLínea 15\nLínea 16\nLínea 17\nLínea 18\nLínea 19\nLínea 20"
;
Spider
string_simbolos
=
"Este string contiene símbolos que son tokens en Notch Engine: +, -, *, //, %, :+, :-, :*, :%, ://, @, [], {}, {: :}, {/ /}, >>. También incluye palabras reservadas como WorldName, Inventory, SpawnPoint, craft, respawn, soulsand, magma, etc."
;
Spider
string_extremo
=
"Este string es extremadamente largo AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA, superando los dos mil caracteres para realmente llevar al límite la capacidad del analizador léxico. En el desarrollo de compiladores e intérpretes, es fundamental probar cómo maneja el sistema casos extremos como este. Cualquier limitación no prevista en el diseño podría manifestarse al procesar tokens de este tamaño. En Minecraft, esto sería equivalente a construir una estructura colosal que se extiende por miles de bloques en todas direcciones, poniendo a prueba los límites del motor del juego. Los analizadores léxicos deben estar preparados para manejar tokens de cualquier longitud razonable, ya que en aplicaciones del mundo real, los usuarios pueden necesitar procesar textos extremadamente largos. Ejemplos incluyen el procesamiento de documentos completos, archivos de configuración extensos, o incluso código generado automáticamente que puede extenderse por miles de líneas. Este string sigue creciendo, añadiendo más y más palabras y caracteres, para asegurar que realmente ponga a prueba los límites del buffer del analizador. Una implementación robusta debería manejar este token sin problemas, reconociéndolo correctamente como un único string literal completo, sin importar su tamaño. El tamaño máximo debería estar limitado únicamente por la memoria disponible en el sistema, no por limitaciones arbitrarias en el diseño del analizador. Este string continúa expandiéndose, añadiendo más contenido para garantizar que supere cualquier buffer de tamaño fijo que pueda haber sido implementado. Es importante también verificar que el rendimiento del analizador no se degrade exponencialmente con tokens muy grandes, lo que podría indicar algoritmos ineficientes. En el contexto de Notch Engine, inspirado en Minecraft, este string sería como un libro dentro del juego con una historia increíblemente detallada que se extiende por múltiples páginas. El analizador léxico debe procesar este token de manera eficiente, reconociéndolo como un único string literal y no fragmentándolo incorrectamente en múltiples tokens. Este string sigue creciendo, agregando más y más caracteres, para asegurar que realmente ponga a prueba los límites del analizador léxico. Continúa expandiéndose, como un mundo de Minecraft que se genera infinitamente, añadiendo más palabras y frases para llegar a una longitud verdaderamente extrema. Este string sigue y sigue y sigue, desafiando las capacidades del analizador, probando su robustez y eficiencia al manejar casos extremos como este."
;
SpawnPoint
PolloCrudo
dropperSpider
(
"Prueba de strings largos completada"
)
;
Stack
longitud
=
#
(
string_largo
)
;
dropperStack
(
longitud
)
;
Spider
subcadena
=
from
string_largo
#
#
0
#
#
50
;
dropperSpider
(
subcadena
)
;
PolloAsado
worldSave
WorldName
PruebaNumeroGrande
:
Bedrock
Obsidian
Stack
NUM_PEQUENO
42
;
Obsidian
Stack
NUM_MEDIANO
12345
;
Obsidian
Stack
NUM_GRANDE
9876543210
;
Obsidian
Stack
NUM_MUY_GRANDE
1234567890123456789
;
Obsidian
Stack
NEG_PEQUENO
-
42
;
Obsidian
Stack
NEG_MEDIANO
-
12345
;
Obsidian
Stack
NEG_GRANDE
-
9876543210
;
Obsidian
Stack
NEG_MUY_GRANDE
-
1234567890123456789
;
Obsidian
Stack
INT_16BIT_MAX
32767
;
Obsidian
Stack
INT_16BIT_MIN
-
32768
;
Obsidian
Stack
INT_32BIT_MAX
2147483647
;
Obsidian
Stack
INT_32BIT_MIN
-
2147483648
;
Obsidian
Stack
INT_64BIT_MAX
9223372036854775807
;
Obsidian
Stack
INT_64BIT_MIN
-
9223372036854775808
;
Obsidian
Stack
NUM_EXTREMO
123456789012345678901234567890
;
Obsidian
Stack
NEG_EXTREMO
-
123456789012345678901234567890
;
Inventory
Stack
num1
=
1234567890
;
Stack
num2
=
9876543210
;
Stack
grande1
=
123456789012345678
;
Stack
grande2
=
987654321098765432
;
Stack
max16
=
32767
;
Stack
min16
=
-
32768
;
Stack
max32
=
2147483647
;
Stack
min32
=
-
2147483648
;
Stack
max64
=
9223372036854775807
;
Stack
min64
=
-
9223372036854775808
;
Stack
extremo
=
123456789012345678901234567890
;
Shelf
[
2147483647
]
Stack
arregloGrande
;
Stack
suma
;
Stack
resta
;
Stack
multiplicacion
;
Stack
division
;
Stack
modulo
;
SpawnPoint
PolloCrudo
suma
=
num1
+
num2
;
resta
=
num2
-
num1
;
multiplicacion
=
num1
*
10
;
division
=
num2
10
;
modulo
=
num2
%
10
;
Stack
resultado1
=
grande1
+
grande2
;
Stack
resultado2
=
extremo
1000
;
Stack
posible_overflow
=
max32
+
1
;
Stack
posible_underflow
=
min32
-
1
;
Stack
producto_grande
=
grande1
*
grande2
;
Stack
division_extrema
=
extremo
3
;
dropperStack
(
suma
)
;
dropperStack
(
resta
)
;
dropperStack
(
multiplicacion
)
;
dropperStack
(
division
)
;
target
producto_grande
>
0
craft
hit
PolloCrudo
dropperSpider
(
"El resultado es positivo"
)
;
PolloAsado
Stack
i
=
0
;
repeater
i
<
5
craft
PolloCrudo
dropperStack
(
i
)
;
dropperStack
(
grande1
)
;
soulsand
i
;
PolloAsado
PolloAsado
worldSave
WorldName
PruebaPrecisionFlotante
:
Bedrock
Obsidian
Ghast
PI_SIMPLE
3.14
;
Obsidian
Ghast
PI_PRECISO
3.14159265358979323846
;
Obsidian
Ghast
EULER
2.71828182845904523536
;
Obsidian
Ghast
RAIZ_DOS
1.41421356237309504880
;
Obsidian
Ghast
PHI
1.61803398874989484820
;
Obsidian
Ghast
SPEED_OF_LIGHT
2.99792458
e8
;
Obsidian
Ghast
PLANCK_CONSTANT
6.62607015
e
-
34
;
Obsidian
Ghast
AVOGADRO
6.02214076
e23
;
Obsidian
Ghast
EXTREMO_PEQUENO
0.0000000000000000000000001
;
Obsidian
Ghast
EXTREMO_GRANDE
123456789012345678901234.5678901234567890
;
Obsidian
Ghast
NEG_PI
-
3.14159265358979
;
Obsidian
Ghast
NEG_EXTREMO
-
0.0000000000000000000000001
;
Obsidian
Ghast
CERO_DECIMAL
0.0
;
Obsidian
Ghast
SOLO_ENTERO
42.0
;
Obsidian
Ghast
SOLO_DECIMAL
0.42
;
Obsidian
Ghast
PUNTO_INICIAL
.
5
;
Inventory
Ghast
normal
=
3.14
;
Ghast
preciso
=
3.141592653589793
;
Ghast
pequeno
=
0.000000000123
;
Ghast
grande
=
1234567890.123456789
;
Ghast
punto_inicial
=
.
25
;
Ghast
sin_decimal
=
42
.
;
Ghast
cientifico1
=
1.23
e5
;
Ghast
cientifico2
=
4.56
e
-
7
;
Ghast
cientifico3
=
7.89
e
+
12
;
Ghast
muy_pequeno
=
0.000000000000000000000000000000000001
;
Ghast
muy_grande
=
999999999999999999999999999999999999999.9
;
Ghast
muchos_digitos
=
123456789012345.678901234567890
;
Ghast
neg_normal
=
-
3.14
;
Ghast
neg_preciso
=
-
3.141592653589793
;
Ghast
neg_pequeno
=
-
0.000000000123
;
Ghast
neg_cientifico
=
-
2.998
e8
;
Ghast
resultado1
;
Ghast
resultado2
;
Ghast
resultado3
;
SpawnPoint
PolloCrudo
resultado1
=
normal
:
+
preciso
;
resultado2
=
preciso
:
-
normal
;
resultado3
=
normal
:
*
2.0
;
Ghast
res_extremo1
=
muy_pequeno
:
*
1000000.0
;
Ghast
res_extremo2
=
muy_grande
:
1000000.0
;
Ghast
division1
=
1.0
:
3.0
;
Ghast
division2
=
2.0
:
3.0
;
Ghast
division_extrema
=
1.0
:
9999999999.0
;
Ghast
res_cientifico
=
cientifico1
:
*
cientifico2
;
dropperGhast
(
resultado1
)
;
dropperGhast
(
resultado2
)
;
dropperGhast
(
division1
)
;
dropperGhast
(
division2
)
;
target
division1
:
<
0.34
craft
hit
PolloCrudo
dropperSpider
(
"La división 1/3 es menor que 0.34"
)
;
PolloAsado
Ghast
i
=
0.0
;
repeater
i
:
<
1.0
craft
PolloCrudo
dropperGhast
(
i
)
;
i
=
i
:
+
0.2
;
PolloAsado
PolloAsado
worldSave
WorldName
PruebaComentarioLargo
:
Inventory
Stack
contador
=
0
;
Stack
despues_comentario
=
1
;
Spider
mensaje
=
"Prueba de comentarios largos"
;
SpawnPoint
PolloCrudo
Stack
i
=
0
;
repeater
i
<
5
craft
PolloCrudo
soulsand
i
;
dropperSpider
(
mensaje
bind
" - iteración "
bind
i
)
;
PolloAsado
dropperSpider
(
"Prueba de comentarios largos completada"
)
;
PolloAsado
worldSave
WorldName
PruebaTokensConsecutivos
:
Bedrock
Obsidian
Stack
MAX_LEVEL5
100
;
Obsidian
Stack
LEVEL_PLUS_SKILL
200
;
Obsidian
Stack
OFFSET_MINUS_5
50
;
Inventory
Stack
a
=
5
;
Stack
b
=
10
;
Stack
c
=
a
+
b
;
Stack
suma
=
5
+
3
;
Stack
resta
=
10
-
7
;
Stack
multiplicacion
=
4
*
3
;
Stack
division
=
20
4
;
Stack
modulo
=
7
%
2
;
Torch
comparacion1
=
5
<
10
;
Torch
comparacion2
=
5
>
3
;
Torch
comparacion3
=
5
<=
5
;
Torch
comparacion4
=
5
>=
5
;
Torch
comparacion5
=
5
is5
;
Torch
comparacion6
=
5
isNot6
;
Stack
expr1
=
5
+
3
*
2
;
Stack
expr2
=
(
5
+
3
)
*
2
;
Stack
expr3
=
5
+
(
3
*
2
)
;
Ghast
f1
=
3.14
;
Ghast
f2
=
f1
:
+
2.5
;
Ghast
f3
=
f1
:
-
1.5
;
Ghast
f4
=
f1
:
*
2.0
;
Ghast
f5
=
f1
:
1.5
;
Shelf
[
5
]
Stack
arreglo
;
Entity
Jugador
PolloCrudo
Spider
nombre
;
Stack
nivel
;
PolloAsado
;
Spider
texto
=
"Hola"
;
Rune
caracter
=
'A'
;
Torch
booleano
=
On
;
Stack
arr
[
0
]
=
10
;
Stack
x
=
1
,
y
=
2
,
z
=
3
;
Stack
normal1
=
10
;
Stack
normal2
=
20
;
Spider
mensaje
=
"Tokens consecutivos"
;
SpawnPoint
PolloCrudo
suma
=
normal1
+
normal2
;
Stack
valor
=
(
normal1
+
5
)
*
(
normal2
-
5
)
;
repeater
suma
>
0
hit
PolloCrudo
suma
=
suma
-
1
;
dropperStack
(
suma
)
;
PolloAsado
target
valor
>=
100
hit
PolloCrudo
dropperSpider
(
"Valor grande"
)
;
PolloAsado
miss
PolloCrudo
dropperSpider
(
"Valor pequeño"
)
;
PolloAsado
dropperSpider
(
mensaje
)
;
dropperStack
(
valor
)
;
normal1
+
=
5
;
normal2
-
=
3
;
dropperStack
(
normal1
)
;
dropperStack
(
normal2
)
;
PolloAsado
worldSave
WorldName
PruebaCaracteresInvalidos
:
Bedrock
Obsidian
Stack
NORMAL
100
;
Obsidian
Stack
ÑANDU
200
;
Obsidian
Stack
AÇÚCAR
300
;
Obsidian
Stack
CAFÉ
400
;
Inventory
Stack
contador
=
0
;
Spider
mensaje
=
"Normal"
;
Stack
año
=
2025
;
Stack
piña
=
10
;
Spider
münzen
=
"Monedas"
;
Spider
öffentlich
=
"Público"
;
Stack
cont
ador
=
5
;
Spider
mens
aje
=
"Texto"
;
Stack
contador
=
10
;
Spider
mensaje
=
"Texto"
;
Stack
monedas
=
100
;
Stack
valor
=
50
;
Spider
texto
=
"Copyright"
;
Spider
texto_unicode
=
"Caracteres especiales: áéíóúñÁÉÍÓÚÑ"
;
Spider
texto_emoji
=
"Emojis: 😀🎮🌍💻"
;
Stack
a
b
;
Stack
c
d
;
Stack
e
f
;
Stack
g
h
;
Stack
valor
otro
;
Stack
valor
contador
=
5
;
Stack
otro
valor
=
10
;
Rune
char_1
=
'€'
;
Rune
char_2
=
'✓'
;
SpawnPoint
PolloCrudo
contador
=
1
;
contador
=
contador
2
;
contador
=
contador
2
;
dropperStack
(
año
)
;
dropperSpider
(
texto_unicode
)
;
contador
=
5
10
;
contador
=
5
10
;
contador
=
5
;
contador
=
contador
+
5
;
dropperSpider
(
"Fin de prueba"
)
;
PolloAsado
worldSave
WorldName
PruebaStringNoTerminado
:
Bedrock
Obsidian
Spider
NOMBRE
"Notch Engine"
;
Obsidian
Spider
VERSION
"1.0"
;
Obsidian
Spider
DESCRIPCION
"Un lenguaje basado en Minecraft;
$$ Constante después del error para verificar recuperación
Obsidian Stack MAX_NIVEL 100;
Inventory
$$ Variables con strings correctamente terminados
Spider normal = "
Este
string
está
bien
";
Spider multilinea = "
Este
string
tiene
nmúltiples
líneas
ny
está
bien
terminado
";
$$ Variable con string no terminado - falta comilla de cierre
Spider incompleto = "
Este
string
no
está
terminado
;
Stack
contador
=
0
;
Spider
confuso
=
"Este string tiene una comilla escapada \" pero no está terminado;
$$ String no terminado al final de una línea
Spider final_linea = "
Este
string
termina
la
línea
pero
no
está
cerrado
Spider
siguiente
=
"Este es un nuevo string"
;
Spider
combinado
=
"String no terminado Stack contador = 5;
$$ String con múltiples líneas pero sin terminar
Spider multilinea_incompleto = "
Este
string
tiene
múltiples
líneas
pero
no
está
terminado
correctamente
;
Spider
comentario_inmediato
=
"String terminado correctamente"
Spider
comentario_error
=
"String no terminado$$ Comentario que no salva el error
$$ String no terminado con comentario de bloque al final
Spider bloque_inmediato = "
String
no
terminado
Spider
consecutivo1
=
"Primer string terminado"
;
Spider
consecutivo2
=
"Segundo string no terminado;
Spider consecutivo3 = "
Tercer
string
terminado
";
SpawnPoint
PolloCrudo
$$ Código normal para contraste
dropperSpider("
Este
mensaje
está
bien
formado
");
$$ Instrucción con string no terminado
dropperSpider("
Este
mensaje
no
está
terminado
;
contador
=
1
;
Spider
resultado
=
normal
bind
"Parte no terminada;
$$ String no terminado en una estructura de control
target normal is "
Comparación
no
terminada
craft
hit
PolloCrudo
dropperSpider
(
"Este código nunca se ejecutará"
)
;
PolloAsado
dropperSpider
(
"String final no terminado
PolloAsado
worldSave
$*
Prueba_Err_ComentarioNoTerminado.ne
Propósito: Verificar detección de comentarios de bloque sin cierre
Fecha: 28/04/2025
*$
WorldName PruebaComentarioNoTerminado:
Bedrock
$$ Constantes normales para contraste
Obsidian Stack MAX_LEVEL 100;
$* Comentario de bloque correctamente cerrado *$
Obsidian Stack MIN_LEVEL 1;
$* Comentario de bloque sin cierre - falta el terminador *$
Obsidian Stack MEDIO_LEVEL 50;
Inventory
$$ Variables normales para contraste
Stack contador = 0;
Spider mensaje = "
Hola
Mundo
";
$*
Comentario de bloque multi-línea correctamente terminado
con varias líneas de texto
*$
Stack variable_normal = 5;
$*
Comentario de bloque multi-línea sin terminar
Este comentario no tiene el terminador correspondiente
y debería generar un error
Torch activo = On; $$ Esta línea no debería ser reconocida como código
Stack valor = 10; $$ Esta línea no debería ser reconocida como código
$$ Variables después del error para verificar recuperación
Stack recuperacion = 20;
$* Otro comentario no terminado
con símbolos que podrían confundir al analizador:
* asterisco suelto
$ signo dólar suelto
*$ esto parece un terminador pero no lo es
$* esto parece un iniciador dentro del comentario
$$ Más código después del segundo comentario no terminado
Torch otra_variable = Off;
$* Comentario aparentemente cerrado, pero con un espacio entre * y $
que debería causar que no se reconozca como terminador * $
$$ Código después del tercer comentario no terminado
Stack tercera_recuperacion = 30;
$*
Este comentario tiene una secuencia que parece un terminador,
pero tiene caracteres en medio: *texto$
Por lo tanto, no está realmente terminado.
$$ Último código para verificar recuperación
Stack ultima_recuperacion = 40;
SpawnPoint
PolloCrudo
$$ Código normal para contraste
dropperSpider("
Inicio
de
programa
");
$* Comentario de bloque sin terminar en el SpawnPoint
Esta sección del código no debería ejecutarse
contador = 5;
dropperStack(contador);
$$ Código después del comentario no terminado
Stack final = 100;
dropperStack(final);
dropperSpider("
Fin
de
programa
");
PolloAsado
$$ Esto debería ser código después del SpawnPoint, que no es válido
$$ pero el analizador léxico igual debería procesarlo como tokens
$*
Comentario final sin terminar
Este es el último elemento del archivo
worldSave
$*
Prueba: 37_Prueba_Err_CaracterNoTerminado
Descripción: Verificar detección de literales de carácter sin cierre
Fecha: 28/04/2025
*$
WorldName PruebaCaracterNoTerminado:
Inventory
$$ Casos de caracteres correctamente formados (para comparación)
Rune letraCorrecta = 'A';
Rune digitoCorrecto = '5';
Rune simboloCorrecto = '@';
Rune escapeCorrecto = '\n';
$$ Casos de caracteres sin cierre (errores léxicos)
Rune errorSimple = 'B; $$ Falta comilla de cierre
Rune errorEscape = '\n; $$ Falta comilla de cierre después de secuencia de escape
$$ Caso con apertura pero sin contenido ni cierre
Rune errorVacio = '; $$ Solo comilla de apertura
$$ Caso con múltiples caracteres (error léxico)
Rune errorMultiple = 'ABC; $$ Múltiples caracteres y falta comilla de cierre
$$ Error dentro de una expresión
Stack valor = 5 + (3 * 'x); $$ Falta comilla de cierre en la expresión
SpawnPoint
PolloCrudo
$$ Este carácter inválido debería ser detectado
Rune pruebaError = 'Z;
dropperSpider("
Este
texto
no
debería
ser
alcanzado
debido
al
error
léxico
");
PolloAsado
worldSave
$*
Prueba: 38_Prueba_Err_SimboloDesconocido
Descripción: Verificar detección de símbolos no reconocidos
Fecha: 28/04/2025
*$
WorldName PruebaSimboloDesconocido:
Bedrock
$$ Símbolos válidos para comparación
Obsidian Stack MAX_VALUE 100;
$$ Símbolo no reconocido: flecha de asignación errónea
Obsidian Stack MIN_VALUE => 0; $$ => no es un símbolo válido
Inventory
$$ Símbolos válidos (para comparación)
Stack contador = 10;
Stack resultado = contador + 5;
$$ Símbolos no reconocidos
Stack valor1 = 5 ^ 2; $$ ^ (potencia) no es un símbolo válido
Stack valor2 = 10 \ 3; $$ \ no es un operador válido
Stack valor3 = valor1 ~ valor2; $$ ~ no es un operador válido
$$ Operadores malformados o incompletos
Stack valor4 = 3 : 4; $$ : solo no es un operador válido (debe ser :+, :-, etc.)
Stack valor5 = 7 / 2; $$ / no es válido (debe ser // para división entera)
$$ Uso de símbolos de otros lenguajes
Stack valor6 = 5 ** 2; $$ ** (potencia en Python) no es válido
Torch condicion = (valor5 == valor6); $$ == no es válido (debe ser 'is')
$$ Símbolo inválido en acceso a estructura
Stack elemento = numeros->0; $$ -> no es válido para acceso (debe ser [])
ResourcePack
$$ Símbolo inválido en declaración de tipo
Anvil Stack ==> Spider; $$ ==> no es un símbolo válido (debe ser ->)
SpawnPoint
PolloCrudo
$$ Operadores inválidos en expresiones
Stack a = 5;
Stack b = 10;
Stack c = a ||| b; $$ ||| no es un operador válido
$$ Símbolos inválidos en estructuras de control
target a < b craft hit
PolloCrudo
dropperSpider("
a
es
menor
que
b
");
PolloAsado
?> $$ ?> no es un símbolo válido
$$ Símbolo inválido como terminador de instrucción
Stack valor = 100#
PolloAsado
worldSave
$*
Prueba: 39_Prueba_Comb_Estructura
Descripción: Verificar estructura básica de un programa completo
Fecha: 28/04/2025
*$
WorldName PruebaEstructuraCompleta:
$$ Sección de constantes
Bedrock
Obsidian Stack MAX_NIVEL 100;
Obsidian Spider VERSION "
1.0
.
0
";
Obsidian Torch DEBUG_MODE Off;
Obsidian Ghast PI 3.14159;
$$ Sección de tipos
ResourcePack
Anvil Ghast -> Stack truncate;
Anvil Stack -> Spider;
$$ Definición de un tipo personalizado
Entity Jugador
PolloCrudo
Spider nombre;
Stack nivel;
Ghast salud;
Torch activo;
PolloAsado;
$$ Sección de variables
Inventory
$$ Variables básicas
Stack contador = 0;
Spider mensaje = "
Bienvenido
a
Notch
Engine
";
Torch juego_activo = On;
Ghast temperatura = 21.5;
Chest letras = {: 'a', 'b', 'c' :};
$$ Variables compuestas
Shelf[5] Stack inventario;
Entity Jugador steve;
$$ Sección de prototipos
Recipe
$$ Prototipo de función
Spell calcularDanio(Stack :: nivel, arma; Ghast ref multiplicador) -> Stack;
$$ Prototipo de procedimiento
Ritual mostrarEstado(Spider :: nombre; Stack nivel, salud);
$$ Sección de implementación de rutinas
CraftingTable
$$ Implementación de función
Spell calcularDanio(Stack :: nivel, arma; Ghast ref multiplicador) -> Stack
PolloCrudo
Stack danio_base = nivel * 2;
target arma is 1 hit
PolloCrudo
danio_base *= 2; $$ Arma mejorada
PolloAsado
multiplicador = 1.5; $$ Modificar parámetro por referencia
respawn danio_base;
PolloAsado
$$ Implementación de procedimiento
Ritual mostrarEstado(Spider :: nombre; Stack nivel, salud)
PolloCrudo
dropperSpider("
==
==
=
Estado
del
Jugador
==
==
=
");
dropperSpider("
Nombre
:
" bind nombre);
dropperSpider("
Nivel
:
" bind nivel);
dropperSpider("
Salud
:
" bind salud);
dropperSpider("
==
==
==
==
==
==
==
==
==
==
==
==
==
==
=
");
PolloAsado
$$ Punto de entrada del programa
SpawnPoint
PolloCrudo
$$ Inicialización
steve@nombre = "
Steve
";
steve@nivel = 1;
steve@salud = 20.0;
steve@activo = On;
$$ Entrada y salida
dropperSpider(mensaje);
dropperSpider("
Ingrese
su
nombre
:
");
Spider nombre_jugador = hopperSpider();
$$ Uso de estructuras de control
target #(nombre_jugador) > 0 hit
PolloCrudo
dropperSpider("
Hola
,
" bind nombre_jugador bind "
");
$$ Uso de funciones y procedimientos
Stack danio = calcularDanio(steve@nivel, 1, 1.0);
dropperSpider("
Tu
daño
base
es
:
" bind danio);
ender_pearl mostrarEstado(steve@nombre, steve@nivel, steve@salud);
$$ Bucle
repeater juego_activo
PolloCrudo
dropperSpider("
Continuar
jugando
(
On
Off
)
");
juego_activo = hopperTorch();
target juego_activo hit
PolloCrudo
soulsand steve@nivel;
dropperSpider("
Nivel
aumentado
a
:
" bind steve@nivel);
PolloAsado
PolloAsado
PolloAsado
miss
PolloCrudo
dropperSpider("
Nombre
no
válido
.
");
PolloAsado
$$ Otros tipos de bucles
Stack i = 0;
spawner
PolloCrudo
soulsand i;
inventario[i] = i * 10;
PolloAsado
exhausted i >= 5;
walk j set 0 to 4
PolloCrudo
dropperSpider("
Inventario
[
" bind j bind "
]
:
" bind inventario[j]);
PolloAsado
PolloAsado
worldSave
$*
Prueba: 40_Prueba_Comb_Declaraciones
Descripción: Verificar combinaciones de declaraciones de variables y constantes
Fecha: 28/04/2025
*$
WorldName PruebaCombinacionDeclaraciones:
$$ Sección de constantes con diferentes tipos y complejidades
Bedrock
$$ Constantes simples de tipos básicos
Obsidian Stack MAX_PLAYERS 8;
Obsidian Stack MIN_LEVEL 1;
Obsidian Torch DEBUG_MODE On;
Obsidian Spider GAME_TITLE "
Notch
Engine
";
Obsidian Rune SEPARATOR '_';
Obsidian Ghast GRAVITY 9.8;
$$ Constantes con expresiones
Obsidian Stack MAX_INVENTORY_SIZE 5 * 9;
Obsidian Stack TOTAL_SLOTS MAX_PLAYERS * MAX_INVENTORY_SIZE;
Obsidian Spider FULL_TITLE GAME_TITLE bind "
v1
.
0
";
Obsidian Ghast TERMINAL_VELOCITY GRAVITY :* 3.0;
$$ Constantes con expresiones más complejas
Obsidian Stack DAYS_IN_YEAR 365;
Obsidian Stack DAYS_IN_4_YEARS DAYS_IN_YEAR * 4 + 1;
Obsidian Torch IS_LEAP_YEAR (DAYS_IN_4_YEARS - (DAYS_IN_YEAR * 4)) is 1;
$$ Declaraciones de tipos con diferentes formas
ResourcePack
$$ Conversiones de tipos básicas
Anvil Ghast -> Stack;
Anvil Ghast -> Stack truncate;
Anvil Stack -> Spider;
Anvil Rune -> Stack safe;
$$ Declaraciones de entidades (registros)
Entity Item
PolloCrudo
Spider nombre;
Stack cantidad;
Stack durabilidad;
Torch stackeable;
PolloAsado;
Entity Jugador
PolloCrudo
Spider nombre;
Stack nivel;
Stack experiencia;
Ghast salud;
Ghast hambre;
Torch en_linea;
Entity Item item_principal;
PolloAsado;
Entity Posicion
PolloCrudo
Stack x;
Stack y;
Stack z;
PolloAsado;
$$ Tipos anidados
Entity Mundo
PolloCrudo
Spider nombre;
Stack seed;
Shelf[10] Entity Jugador jugadores;
Entity Posicion spawn;
PolloAsado;
$$ Sección de variables con diferentes formas de declaración e inicialización
Inventory
$$ Declaraciones simples sin inicialización
Stack contador;
Spider mensaje;
Torch estado;
Rune inicial;
Ghast temperatura;
$$ Declaraciones con inicialización
Stack nivel = 1;
Spider nombre = "
Steve
";
Torch activo = On;
Rune tecla = 'A';
Ghast pi = 3.14159;
$$ Declaraciones múltiples del mismo tipo
Stack x = 0, y = 0, z = 0;
Torch jugando = On, pausa = Off, sonido = On;
Ghast distancia = 0.0, velocidad = 5.0, aceleracion = 1.5;
$$ Declaraciones con resultados de expresiones
Stack suma = 5 + 10;
Stack producto = 4 * 25;
Spider saludo = "
Hola
" bind nombre;
Torch condicion = nivel > 5;
Ghast promedio = (10.5 :+ 20.7 :+ 15.3) :// 3.0;
$$ Declaraciones de tipos compuestos
Shelf[5] Stack inventario;
Shelf[3] Spider mensajes = ["
Hola
", "
Mundo
", "
"];
Shelf[2] Shelf[2] Stack matriz;
Chest numeros = {: 1, 2, 3, 4, 5 :};
Book archivo = {/ "
datos
.
txt
", 'E' /};
$$ Instancias de entidades (registros)
Entity Item espada;
Entity Jugador jugador1
PolloCrudo
nombre: "
Alex
";
nivel: 5;
experiencia: 150;
salud: 18.5;
hambre: 16.0;
en_linea: On;
item_principal:
PolloCrudo
nombre: "
Espada
de
diamante
";
cantidad: 1;
durabilidad: 1500;
stackeable: Off;
PolloAsado;
PolloAsado;
Entity Mundo mundo_principal;
SpawnPoint
PolloCrudo
$$ Inicialización de variables declaradas sin valor inicial
contador = 0;
mensaje = "
Variable
inicializada
en
el
punto
de
entrada
";
estado = Off;
inicial = 'Z';
temperatura = 22.5;
$$ Inicialización de variables compuestas
espada@nombre = "
Espada
de
hierro
";
espada@cantidad = 1;
espada@durabilidad = 250;
espada@stackeable = Off;
matriz[0][0] = 1;
matriz[0][1] = 2;
matriz[1][0] = 3;
matriz[1][1] = 4;
mundo_principal@nombre = "
Mundo
de
prueba
";
mundo_principal@seed = 12345;
mundo_principal@spawn@x = 0;
mundo_principal@spawn@y = 64;
mundo_principal@spawn@z = 0;
$$ Uso de constantes en asignaciones
Stack max_jugadores = MAX_PLAYERS;
dropperSpider(FULL_TITLE);
$$ Uso de referencias a variables en asignaciones
Stack total = nivel + jugador1@nivel;
dropperSpider("
Nivel
total
:
" bind total);
PolloAsado
worldSave
$*
Prueba: 41_Prueba_Comb_Expresiones
Descripción: Verificar expresiones aritméticas y lógicas complejas
Fecha: 28/04/2025
*$
WorldName PruebaExpresionesComplejas:
Bedrock
Obsidian Stack BASE_DAMAGE 10;
Obsidian Stack ARMOR_FACTOR 2;
Obsidian Ghast CRIT_MULTIPLIER 1.5;
Obsidian Torch USE_ADVANCED_FORMULAS On;
Inventory
$$ Variables para las pruebas
Stack a = 5;
Stack b = 10;
Stack c = 15;
Stack resultado_entero;
Ghast x = 2.5;
Ghast y = 3.7;
Ghast z = 1.2;
Ghast resultado_flotante;
Torch p = On;
Torch q = Off;
Torch r = On;
Torch resultado_logico;
Spider str1 = "
Notch
";
Spider str2 = "
Engine
";
Spider resultado_string;
Shelf[5] Stack valores = [10, 20, 30, 40, 50];
Entity Jugador
PolloCrudo
Spider nombre;
Stack nivel;
Ghast salud;
PolloAsado;
Entity Jugador jugador;
SpawnPoint
PolloCrudo
$$ 1. Expresiones aritméticas complejas con enteros
resultado_entero = a + b * c;
dropperSpider("
a
+
b
*
c
=
" bind resultado_entero);
resultado_entero = (a + b) * c;
dropperSpider("
(
a
+
b
)
*
c
=
" bind resultado_entero);
resultado_entero = a + b - c * 2 // 3 % 4;
dropperSpider("
a
+
b
-
c
*
2
3
%
4
=
" bind resultado_entero);
resultado_entero = (a + (b - (c * (2 // (3 % 4)))));
dropperSpider("
Anidada
enteros
:
" bind resultado_entero);
soulsand a;
resultado_entero = a + b;
magma b;
dropperSpider("
Después
de
incremento
decremento
:
" bind resultado_entero);
$$ 2. Expresiones aritméticas complejas con flotantes
resultado_flotante = x :+ y :* z;
dropperSpider("
x
:
+
y
:
*
z
=
" bind resultado_flotante);
resultado_flotante = (x :+ y) :* z;
dropperSpider("
(
x
:
+
y
)
:
*
z
=
" bind resultado_flotante);
resultado_flotante = x :+ y :- z :* 2.0 :// 0.5 :% 1.0;
dropperSpider("
x
:
+
y
:
-
z
:
*
2.0
:
0.5
:
%
1.0
=
" bind resultado_flotante);
resultado_flotante = (x :+ (y :- (z :* (2.0 :// (0.5 :% 1.0)))));
dropperSpider("
Anidada
flotantes
:
" bind resultado_flotante);
$$ 3. Expresiones lógicas complejas
resultado_logico = p and q;
dropperSpider("
p
and
q
=
" bind resultado_logico);
resultado_logico = p or q;
dropperSpider("
p
or
q
=
" bind resultado_logico);
resultado_logico = not p;
dropperSpider("
not
p
=
" bind resultado_logico);
resultado_logico = p xor q;
dropperSpider("
p
xor
q
=
" bind resultado_logico);
resultado_logico = p and q or r;
dropperSpider("
p
and
q
or
r
=
" bind resultado_logico);
resultado_logico = p and (q or r);
dropperSpider("
p
and
(
q
or
r
)
=
" bind resultado_logico);
resultado_logico = not (p and q) or (not r and p);
dropperSpider("
not
(
p
and
q
)
or
(
not
r
and
p
)
=
" bind resultado_logico);
$$ 4. Expresiones de comparación
resultado_logico = a < b;
dropperSpider("
a
<
b
=
" bind resultado_logico);
resultado_logico = a > c;
dropperSpider("
a
>
c
=
" bind resultado_logico);
resultado_logico = a <= b and b >= c;
dropperSpider("
a
<=
b
and
b
>=
c
=
" bind resultado_logico);
resultado_logico = (a is b) or (b is c);
dropperSpider("
(
a
is
b
)
or
(
b
is
c
)
=
" bind resultado_logico);
resultado_logico = a isNot b and b isNot c and a isNot c;
dropperSpider("
a
isNot
b
and
b
isNot
c
and
a
isNot
c
=
" bind resultado_logico);
$$ 5. Expresiones mixtas (combinando tipos)
resultado_logico = (a + b > c) and (x :+ y :> z);
dropperSpider("
(
a
+
b
>
c
)
and
(
x
:
+
y
:
>
z
)
=
" bind resultado_logico);
resultado_logico = (a < b) or (not p) and (x :< y);
dropperSpider("
(
a
<
b
)
or
(
not
p
)
and
(
x
:
<
y
)
=
" bind resultado_logico);
$$ 6. Expresiones con operaciones de cadenas
resultado_string = bind(str1, "
" bind str2);
dropperSpider("
bind
result
:
" bind resultado_string);
Stack longitud = #(resultado_string);
dropperSpider("
Length
:
" bind longitud);
resultado_string = from resultado_string ## 0 ## 5;
dropperSpider("
Substring
:
" bind resultado_string);
Stack pos = seek(resultado_string, "
tch
");
dropperSpider("
Position
of
'tch'
:
" bind pos);
$$ 7. Expresiones con accesos a estructuras
Stack valor_arreglo = valores[2] + valores[3] * valores[4];
dropperSpider("
Array
expression
:
" bind valor_arreglo);
jugador@nombre = "
Steve
";
jugador@nivel = 20;
jugador@salud = 18.5;
Stack nivel_con_bonus = jugador@nivel + 5;
dropperSpider("
Nivel
con
bonus
:
" bind nivel_con_bonus);
Torch nivel_alto = jugador@nivel > 15 and jugador@salud :> 15.0;
dropperSpider("
Nivel
alto
:
" bind nivel_alto);
$$ 8. Expresiones con conversiones de tipo
Stack entero_desde_float = x >> Stack;
dropperSpider("
Entero
desde
float
:
" bind entero_desde_float);
Torch bool_desde_entero = a >> Torch;
dropperSpider("
Booleano
desde
entero
:
" bind bool_desde_entero);
$$ 9. Expresiones extremadamente complejas que combinan múltiples elementos
Stack damage = BASE_DAMAGE + ((jugador@nivel // 2) * (valores[1] + valores[3] // 3));
dropperSpider("
Daño
calculado
:
" bind damage);
target USE_ADVANCED_FORMULAS craft hit
PolloCrudo
Ghast damage_final = ((damage >> Ghast) :* CRIT_MULTIPLIER) :// (1.0 :+ ((valores[4] // 10) >> Ghast));
dropperSpider("
Daño
final
(
fórmula
avanzada
)
:
" bind damage_final);
PolloAsado
miss
PolloCrudo
Stack damage_simple = damage * 2 // (ARMOR_FACTOR + (p and q >> Stack));
dropperSpider("
Daño
final
(
fórmula
simple
)
:
" bind damage_simple);
PolloAsado
PolloAsado
worldSave
$*
Prueba: 42_Prueba_Comb_Control.ne
Descripción: Verificar estructuras de control anidadas
Fecha: 28/04/2025
*$
WorldName PruebaControlAnidado:
Inventory
$$ Variables para las pruebas
Stack contador = 0;
Stack max_iteraciones = 5;
Stack resultado = 0;
Stack opcion = 2;
Torch condicion1 = On;
Torch condicion2 = Off;
Spider mensaje = "
Estructuras
de
control
anidadas
";
Spider resultado_texto = "
";
Shelf[5] Stack matriz = [1, 2, 3, 4, 5];
Entity Personaje
PolloCrudo
Spider nombre;
Stack nivel;
Torch activo;
PolloAsado;
Entity Personaje jugador;
SpawnPoint
dropperSpider(mensaje);
jugador@nombre = "
Steve
";
jugador@nivel = 1;
jugador@activo = On;
$$ 1. Condicionales anidados (if-then-else)
target jugador@nivel >= 1 craft hit
PolloCrudo
dropperSpider("
Nivel
suficiente
para
comenzar
");
target jugador@activo craft hit
PolloCrudo
dropperSpider("
Jugador
activo
");
target jugador@nombre is "
Steve
" craft hit
PolloCrudo
dropperSpider("
Bienvenido
,
Steve
");
soulsand jugador@nivel;
PolloAsado
miss
PolloCrudo
dropperSpider("
Bienvenido
,
jugador
desconocido
");
PolloAsado
PolloAsado
miss
PolloCrudo
dropperSpider("
Jugador
inactivo
.
Activando
.
.
.
");
jugador@activo = On;
PolloAsado
PolloAsado
miss
PolloCrudo
dropperSpider("
Nivel
insuficiente
para
comenzar
");
PolloAsado
$$ 2. Switch anidado dentro de if
target opcion > 0 craft hit
PolloCrudo
jukebox opcion craft
disc 1:
PolloCrudo
dropperSpider("
Opción
1
seleccionada
");
target condicion1 craft hit
PolloCrudo
dropperSpider("
Subopción
A
");
PolloAsado
miss
PolloCrudo
dropperSpider("
Subopción
B
");
PolloAsado
PolloAsado
disc 2:
PolloCrudo
dropperSpider("
Opción
2
seleccionada
");
jukebox jugador@nivel craft
disc 1:
PolloCrudo
dropperSpider("
Nivel
básico
");
PolloAsado
disc 2:
PolloCrudo
dropperSpider("
Nivel
intermedio
");
PolloAsado
silence:
PolloCrudo
dropperSpider("
Nivel
desconocido
");
PolloAsado
PolloAsado
silence:
PolloCrudo
dropperSpider("
Opción
no
reconocida
");
PolloAsado
PolloAsado
$$ 3. Bucles anidados - while dentro de for
walk i set 0 to 2 craft
PolloCrudo
dropperSpider("
Iteración
de
for
principal
:
" bind i);
Stack j = 0;
repeater j < 3 craft
PolloCrudo
dropperSpider("
Subiteración
de
while
:
" bind j);
resultado += (i * 10 + j);
soulsand j;
PolloAsado
PolloAsado
dropperSpider("
Resultado
acumulado
:
" bind resultado);
$$ 4. Bucle do-while con if anidado
contador = 0;
resultado = 0;
spawner
PolloCrudo
soulsand contador;
dropperSpider("
Iteración
do
-
while
:
" bind contador);
target contador % 2 is 0 craft hit
PolloCrudo
dropperSpider("
Número
par
detectado
");
resultado += contador;
PolloAsado
miss
PolloCrudo
dropperSpider("
Número
impar
detectado
");
resultado += contador * 2;
PolloAsado
PolloAsado
exhausted contador >= max_iteraciones;
dropperSpider("
Resultado
tras
do
-
while
:
" bind resultado);
$$ 5. Bucles for anidados con break y continue
resultado = 0;
walk i set 0 to 5 craft
PolloCrudo
target i is 3 craft hit
PolloCrudo
dropperSpider("
Saltando
iteración
i
=
3
");
enderPearl;
PolloAsado
dropperSpider("
For
externo
:
" bind i);
walk j set 0 to 3 craft
PolloCrudo
target i is 4 and j > 1 craft hit
PolloCrudo
dropperSpider("
Terminando
loop
interno
en
i
=
4
,
j
=
" bind j);
creeper;
PolloAsado
resultado += (i + j);
dropperSpider("
For
interno
:
j
=
" bind j bind "
,
suma
acumulada
=
" bind resultado);
PolloAsado
PolloAsado
$$ 6. Combinación compleja: with dentro de if-else dentro de while
contador = 0;
resultado = 0;
repeater contador < 3 craft
PolloCrudo
soulsand contador;
dropperSpider("
Iteración
while
principal
:
" bind contador);
target contador % 2 is 0 craft hit
PolloCrudo
wither jugador craft
PolloCrudo
activo = Off;
dropperSpider("
" bind nombre bind "
desactivado
temporalmente
");
spawner
PolloCrudo
soulsand nivel;
dropperSpider("
Incrementando
nivel
:
" bind nivel);
PolloAsado
exhausted nivel > contador + 2;
activo = On;
dropperSpider("
" bind nombre bind "
reactivado
con
nivel
" bind nivel);
PolloAsado
PolloAsado
miss
PolloCrudo
Stack temp_nivel = jugador@nivel;
repeater temp_nivel > 0 craft
PolloCrudo
dropperSpider("
Reduciendo
nivel
temporal
:
" bind temp_nivel);
target temp_nivel is 1 craft hit
PolloCrudo
dropperSpider("
Nivel
mínimo
alcanzado
");
creeper;
PolloAsado
magma temp_nivel;
PolloAsado
PolloAsado
PolloAsado
$$ 7. Estructuras de control con expresiones complejas en las condiciones
walk i set 0 to matriz[2] + matriz[4] // 2 craft
PolloCrudo
target (i * 2 <= matriz[i % 5]) and ((i % 2 is 0) or (i is matriz[0])) craft hit
PolloCrudo
dropperSpider("
Condición
compleja
satisfecha
en
i
=
" bind i);
resultado += i;
PolloAsado
PolloAsado
dropperSpider("
Resultado
final
:
" bind resultado);
$$ 8. Instrucción ragequit condicionada anidada
target contador >= max_iteraciones and resultado < 100 craft hit
PolloCrudo
target jugador@nivel < 5 craft hit
PolloCrudo
dropperSpider("
Condiciones
críticas
alcanzadas
.
Terminando
programa
.
");
ragequit;
PolloAsado
PolloAsado
dropperSpider("
Programa
completado
con
éxito
.
");
worldSave
$*
Prueba: 43_Prueba_Rend_MuchosTokens
Descripción: Verificar rendimiento con un archivo con miles de tokens
Fecha: 28/04/2025
*$
WorldName PruebaMuchosTokens:
Bedrock
Obsidian Stack MAX_ITERATIONS 1000;
Obsidian Stack ARRAY_SIZE 500;
Obsidian Stack STEP_VALUE 1;
Obsidian Spider TEST_NAME "
Prueba
de
rendimiento
con
muchos
tokens
";
ResourcePack
Entity TestData
PolloCrudo
Stack id;
Stack value;
Ghast weight;
Spider name;
Torch active;
PolloAsado;
Inventory
$$ Declaramos variables extensas para generar muchos tokens
Shelf[500] Stack numbers;
$$ Creamos un array grande de registros
Shelf[100] Entity TestData records;
$$ Variables para el procesamiento
Stack counter;
Stack sum;
Stack product;
Stack max_value;
Stack min_value;
Ghast average;
Stack i;
Stack j;
Stack k;
Stack temp;
Torch condition;
SpawnPoint
dropperSpider(TEST_NAME);
dropperSpider("
Inicializando
arrays
.
.
.
");
$$ Inicialización masiva del array de enteros
walk i set 0 to ARRAY_SIZE - 1 craft
PolloCrudo
numbers[i] = i * STEP_VALUE;
PolloAsado
$$ Inicialización del array de registros
walk i set 0 to 99 craft
PolloCrudo
records[i]@id = i;
records[i]@value = i * 10;
records[i]@weight = i :* 0.5;
records[i]@name = "
Item_
" bind i;
records[i]@active = i % 2 is 0;
PolloAsado
dropperSpider("
Realizando
cálculos
.
.
.
");
$$ Cálculos repetitivos generando miles de tokens
sum = 0;
product = 1;
max_value = numbers[0];
min_value = numbers[0];
$$ Bucle con muchas operaciones
walk i set 0 to ARRAY_SIZE - 1 craft
PolloCrudo
$$ Acumuladores simples
sum += numbers[i];
$$ Para evitar overflow, sólo multiplicamos los primeros 10 valores
target i < 10 craft hit
PolloCrudo
product *= numbers[i] + 1;
PolloAsado
$$ Cálculo de máximo y mínimo
target numbers[i] > max_value craft hit
PolloCrudo
max_value = numbers[i];
PolloAsado
target numbers[i] < min_value craft hit
PolloCrudo
min_value = numbers[i];
PolloAsado
$$ Operaciones condicionales adicionales
target i % 50 is 0 craft hit
PolloCrudo
dropperSpider("
Procesado
" bind i bind "
elementos
.
.
.
");
PolloAsado
PolloAsado
$$ Cálculo de promedio
average = sum >> Ghast :// (ARRAY_SIZE >> Ghast);
dropperSpider("
Procesamiento
completado
.
Resultados
:
");
dropperSpider("
Suma
total
:
" bind sum);
dropperSpider("
Producto
(
primeros
10
)
:
" bind product);
dropperSpider("
Valor
máximo
:
" bind max_value);
dropperSpider("
Valor
mínimo
:
" bind min_value);
dropperSpider("
Promedio
:
" bind average);
$$ Procesamiento de registros - para generar más tokens
dropperSpider("
Procesando
registros
.
.
.
");
counter = 0;
walk i set 0 to 99 craft
PolloCrudo
target records[i]@active craft hit
PolloCrudo
soulsand counter;
$$ Actualizar el valor basado en otros registros
walk j set 0 to i craft
PolloCrudo
records[i]@value += j;
PolloAsado
PolloAsado
PolloAsado
dropperSpider("
Registros
activos
:
" bind counter);
$$ Algoritmo de ordenamiento burbuja para generar aún más tokens
dropperSpider("
Ordenando
array
.
.
.
");
walk i set 0 to ARRAY_SIZE - 2 craft
PolloCrudo
walk j set 0 to ARRAY_SIZE - i - 2 craft
PolloCrudo
target numbers[j] > numbers[j + 1] craft hit
PolloCrudo
$$ Intercambio
temp = numbers[j];
numbers[j] = numbers[j + 1];
numbers[j + 1] = temp;
PolloAsado
PolloAsado
PolloAsado
dropperSpider("
Array
ordenado
.
");
$$ Búsqueda binaria para generar más tokens
dropperSpider("
Realizando
búsquedas
.
.
.
");
walk k set 0 to 20 craft
PolloCrudo
Stack valor_buscar = k * 25;
Stack inicio = 0;
Stack fin = ARRAY_SIZE - 1;
Stack medio;
Stack encontrado = 0;
repeater inicio <= fin craft
PolloCrudo
medio = (inicio + fin) // 2;
target numbers[medio] is valor_buscar craft hit
PolloCrudo
encontrado = 1;
creeper;
PolloAsado
target numbers[medio] < valor_buscar craft hit
PolloCrudo
inicio = medio + 1;
PolloAsado
miss
PolloCrudo
fin = medio - 1;
PolloAsado
PolloAsado
target encontrado craft hit
PolloCrudo
dropperSpider("
Valor
" bind valor_buscar bind "
encontrado
en
posición
" bind medio);
PolloAsado
miss
PolloCrudo
dropperSpider("
Valor
" bind valor_buscar bind "
no
encontrado
");
PolloAsado
PolloAsado
dropperSpider("
Prueba
de
rendimiento
completada
.
");
worldSave
$*
Prueba: 44_Prueba_Rend_TokensRepetidos
Descripción: Verificar rendimiento con patrones repetitivos
Fecha: 28/04/2025
*$
WorldName PruebaTokensRepetidos:
Bedrock
Obsidian Stack MAX_ITERATIONS 500;
Obsidian Stack PATTERN_LENGTH 20;
Inventory
$$ Variables para la prueba
Stack counter = 0;
Stack total = 0;
Stack temp = 0;
Torch flag = On;
SpawnPoint
dropperSpider("
Iniciando
prueba
de
rendimiento
con
tokens
repetitivos
");
$$ =================================================================
$$ Patrón 1: Repetición masiva de operaciones aritméticas
$$ =================================================================
counter = 0;
total = 0;
repeater counter < MAX_ITERATIONS craft
PolloCrudo
$$ Patrón de operaciones aritméticas que se repite
total = total + 1;
total = total - 1;
total = total + 2;
total = total - 1;
total = total + 3;
total = total - 2;
total = total * 2;
total = total // 2;
total = total + 5;
total = total % 10;
total = total + 1;
total = total - 1;
total = total + 2;
total = total - 1;
total = total + 3;
total = total - 2;
total = total * 2;
total = total // 2;
total = total + 5;
total = total % 10;
soulsand counter;
PolloAsado
dropperSpider("
Patrón
1
completado
.
Total
:
" bind total);
$$ =================================================================
$$ Patrón 2: Repetición masiva de operaciones lógicas
$$ =================================================================
counter = 0;
flag = On;
repeater counter < MAX_ITERATIONS craft
PolloCrudo
$$ Patrón de operaciones lógicas que se repite
flag = flag and On;
flag = flag or Off;
flag = not flag;
flag = flag and On;
flag = flag or Off;
flag = not flag;
flag = flag xor On;
flag = flag xor Off;
flag = flag and On;
flag = not flag;
flag = flag and On;
flag = flag or Off;
flag = not flag;
flag = flag and On;
flag = flag or Off;
flag = not flag;
flag = flag xor On;
flag = flag xor Off;
flag = flag and On;
flag = not flag;
soulsand counter;
PolloAsado
dropperSpider("
Patrón
2
completado
.
Estado
final
:
" bind flag);
$$ =================================================================
$$ Patrón 3: Repetición masiva de evaluaciones condicionales
$$ =================================================================
counter = 0;
total = 0;
repeater counter < MAX_ITERATIONS craft
PolloCrudo
$$ Patrón de condicionales que se repite
target counter % 2 is 0 craft hit
PolloCrudo
total += 1;
PolloAsado
miss
PolloCrudo
total += 2;
PolloAsado
target counter % 3 is 0 craft hit
PolloCrudo
total += 3;
PolloAsado
miss
PolloCrudo
total += 1;
PolloAsado
target counter % 5 is 0 craft hit
PolloCrudo
total += 5;
PolloAsado
miss
PolloCrudo
total += 2;
PolloAsado
target counter % 7 is 0 craft hit
PolloCrudo
total += 7;
PolloAsado
miss
PolloCrudo
total += 3;
PolloAsado
target total > 1000 craft hit
PolloCrudo
total = total % 1000;
PolloAsado
soulsand counter;
PolloAsado
dropperSpider("
Patrón
3
completado
.
Total
:
" bind total);
$$ =================================================================
$$ Patrón 4: Repetición masiva de incremento/decremento
$$ =================================================================
counter = 0;
total = 500;
repeater counter < MAX_ITERATIONS craft
PolloCrudo
$$ Patrón de incremento/decremento que se repite
soulsand total;
soulsand total;
soulsand total;
magma total;
magma total;
soulsand total;
soulsand total;
magma total;
soulsand total;
magma total;
soulsand total;
soulsand total;
soulsand total;
magma total;
magma total;
soulsand total;
soulsand total;
magma total;
soulsand total;
magma total;
soulsand counter;
PolloAsado
dropperSpider("
Patrón
4
completado
.
Total
:
" bind total);
$$ =================================================================
$$ Patrón 5: Repetición masiva de operaciones de asignación compuesta
$$ =================================================================
counter = 0;
total = 5;
repeater counter < MAX_ITERATIONS craft
PolloCrudo
$$ Patrón de asignaciones compuestas que se repite
total += 5;
total -= 2;
total *= 2;
total //= 2;
total %= 10;
total += 1;
total -= 1;
total *= 3;
total //= 3;
total %= 5;
total += 5;
total -= 2;
total *= 2;
total //= 2;
total %= 10;
total += 1;
total -= 1;
total *= 3;
total //= 3;
total %= 5;
soulsand counter;
PolloAsado
dropperSpider("
Patrón
5
completado
.
Total
:
" bind total);
$$ =================================================================
$$ Patrón 6: Repetición masiva de operadores de comparación
$$ =================================================================
counter = 0;
total = 0;
temp = 50;
repeater counter < MAX_ITERATIONS craft
PolloCrudo
$$ Patrón de comparaciones que se repite
target counter < temp craft hit total += 1; PolloAsado
target counter > temp craft hit total += 1; PolloAsado
target counter <= temp craft hit total += 1; PolloAsado
target counter >= temp craft hit total += 1; PolloAsado
target counter is temp craft hit total += 1; PolloAsado
target counter isNot temp craft hit total += 1; PolloAsado
target counter < 100 craft hit total += 1; PolloAsado
target counter > 0 craft hit total += 1; PolloAsado
target counter <= 100 craft hit total += 1; PolloAsado
target counter >= 0 craft hit total += 1; PolloAsado
target counter < temp craft hit total += 1; PolloAsado
target counter > temp craft hit total += 1; PolloAsado
target counter <= temp craft hit total += 1; PolloAsado
target counter >= temp craft hit total += 1; PolloAsado
target counter is temp craft hit total += 1; PolloAsado
target counter isNot temp craft hit total += 1; PolloAsado
target counter < 100 craft hit total += 1; PolloAsado
target counter > 0 craft hit total += 1; PolloAsado
target counter <= 100 craft hit total += 1; PolloAsado
target counter >= 0 craft hit total += 1; PolloAsado
soulsand counter;
PolloAsado
dropperSpider("
Patrón
6
completado
.
Total
:
" bind total);
dropperSpider("
Prueba
de
rendimiento
con
tokens
repetitivos
completada
.
");
worldSave
$*
Prueba: 45_Prueba_Rend_TokensVariados
Descripción: Verificar rendimiento con variedad de tokens mezclados
Fecha: 28/04/2025
*$
WorldName PruebaTokensVariados:
$$ Sección de constantes para controlar el tamaño de la prueba
Bedrock
Obsidian Stack ITERATIONS 100;
Obsidian Stack MAX_VALUE 1000;
Obsidian Stack ARRAY_SIZE 50;
Obsidian Spider TEST_NAME "
Prueba
de
rendimiento
con
tokens
variados
";
Obsidian Spider VERSION "
1.0
";
Obsidian Ghast PI 3.14159;
Obsidian Torch DEBUG_MODE On;
$$ Definiciones de tipos variados para generar diversidad de tokens
ResourcePack
Entity Posicion
PolloCrudo
Stack x;
Stack y;
Stack z;
PolloAsado;
Entity Item
PolloCrudo
Spider nombre;
Stack cantidad;
Stack durabilidad;
Ghast peso;
Torch consumible;
PolloAsado;
Entity Jugador
PolloCrudo
Spider nombre;
Stack nivel;
Ghast salud;
Entity Posicion posicion;
Shelf[10] Entity Item inventario;
PolloAsado;
Anvil Ghast -> Stack truncate;
Anvil Stack -> Spider;
Anvil Spider -> Stack;
Anvil Stack -> Torch;
Inventory
Stack contador = 0;
Stack suma = 0;
Stack producto = 1;
Ghast pi = 3.14159;
Ghast e = 2.71828;
Ghast resultado_flotante = 0.0;
Spider texto = "
Prueba
de
rendimiento
";
Spider resultado_texto = "
";
Rune caracter = 'A';
Torch condicion = On;
Shelf[ARRAY_SIZE] Stack numeros;
Shelf[ARRAY_SIZE] Ghast valores_reales;
Shelf[10] Spider textos = ["
uno
", "
dos
", "
tres
", "
cuatro
", "
cinco
", "
seis
", "
siete
", "
ocho
", "
nueve
", "
diez
"];
Chest conjunto_numeros = {: 1, 2, 3, 4, 5 :};
Chest conjunto_caracteres = {: 'a', 'b', 'c', 'd', 'e' :};
Book archivo_log = {/ "
log
.
txt
", 'E' /};
Book archivo_datos = {/ "
datos
.
dat
", 'L' /};
Entity Posicion origen
PolloCrudo
x: 0;
y: 0;
z: 0;
PolloAsado;
Entity Item espada
PolloCrudo
nombre: "
Espada
de
diamante
";
cantidad: 1;
durabilidad: 1000;
peso: 5.0;
consumible: Off;
PolloAsado;
Entity Jugador jugador_principal;
Entity Jugador jugadores[5];
Recipe
Spell calcularDanio(Stack :: nivel; Ghast :: multiplicador) -> Stack;
Spell distanciaEntre(Entity Posicion :: pos1, pos2) -> Ghast;
Spell crearItem(Spider :: nombre; Stack cantidad, durabilidad; Ghast peso; Torch consumible) -> Entity Item;
Ritual inicializarJugador(Entity Jugador ref jugador; Spider :: nombre; Stack nivel; Ghast salud);
Ritual mostrarEstadisticas(Entity Jugador :: jugador);
Ritual procesarInventario(Shelf[10] Entity Item :: inventario);
CraftingTable
Spell calcularDanio(Stack :: nivel; Ghast :: multiplicador) -> Stack
PolloCrudo
Stack danio_base = nivel * 2 + 5;
Stack danio_final = danio_base;
target nivel > 10 craft hit
PolloCrudo
danio_final += (nivel - 10) * 3;
PolloAsado
Ghast temp = danio_final >> Ghast;
temp = temp :* multiplicador;
danio_final = temp >> Stack;
respawn danio_final;
PolloAsado
Spell distanciaEntre(Entity Posicion :: pos1, pos2) -> Ghast
PolloCrudo
Stack dx = pos1@x - pos2@x;
Stack dy = pos1@y - pos2@y;
Stack dz = pos1@z - pos2@z;
Ghast dx_float = dx >> Ghast;
Ghast dy_float = dy >> Ghast;
Ghast dz_float = dz >> Ghast;
Ghast suma_cuadrados = (dx_float :* dx_float) :+ (dy_float :* dy_float) :+ (dz_float :* dz_float);
Ghast result = suma_cuadrados :// 2.0;
respawn result;
PolloAsado
Spell crearItem(Spider :: nombre; Stack cantidad, durabilidad; Ghast peso; Torch consumible) -> Entity Item
PolloCrudo
Entity Item nuevo_item
PolloCrudo
nombre: nombre;
cantidad: cantidad;
durabilidad: durabilidad;
peso: peso;
consumible: consumible;
PolloAsado;
respawn nuevo_item;
PolloAsado
Ritual inicializarJugador(Entity Jugador ref jugador; Spider :: nombre; Stack nivel; Ghast salud)
PolloCrudo
jugador@nombre = nombre;
jugador@nivel = nivel;
jugador@salud = salud;
jugador@posicion@x = 0;
jugador@posicion@y = 0;
jugador@posicion@z = 0;
walk i set 0 to 9 craft
PolloCrudo
jugador@inventario[i] = crearItem("
Item_
" bind i, i + 1, 100 * (i + 1), i :* 0.5, i % 2 is 0);
PolloAsado
PolloAsado
Ritual mostrarEstadisticas(Entity Jugador :: jugador)
PolloCrudo
dropperSpider("
==
=
Estadísticas
del
Jugador
==
=
");
dropperSpider("
Nombre
:
" bind jugador@nombre);
dropperSpider("
Nivel
:
" bind jugador@nivel);
dropperSpider("
Salud
:
" bind jugador@salud);
dropperSpider("
Posición
:
(
" bind jugador@posicion@x bind "
,
" bind jugador@posicion@y bind "
,
" bind jugador@posicion@z bind "
)
");
dropperSpider("
Inventario
:
" bind #(jugador@inventario) bind "
items
");
PolloAsado
Ritual procesarInventario(Shelf[10] Entity Item :: inventario)
PolloCrudo
Stack total_items = 0;
Ghast peso_total = 0.0;
Spider lista_items = "
";
walk i set 0 to 9 craft
PolloCrudo
total_items += inventario[i]@cantidad;
peso_total = peso_total :+ (inventario[i]@peso :* inventario[i]@cantidad >> Ghast);
target i < 9 craft hit
PolloCrudo
lista_items = lista_items bind inventario[i]@nombre bind "
,
";
PolloAsado
miss
PolloCrudo
lista_items = lista_items bind inventario[i]@nombre;
PolloAsado
PolloAsado
dropperSpider("
Total
items
:
" bind total_items);
dropperSpider("
Peso
total
:
" bind peso_total);
dropperSpider("
Lista
:
" bind lista_items);
PolloAsado
SpawnPoint
dropperSpider(TEST_NAME bind "
v
" bind VERSION);
walk i set 0 to ARRAY_SIZE - 1 craft
PolloCrudo
numeros[i] = (i * i + i) % MAX_VALUE;
valores_reales[i] = i :* PI :// 10.0;
target i < 20 craft hit
PolloCrudo
add(conjunto_numeros, i * 10);
PolloAsado
PolloAsado
jugador_principal@nombre = "
Aventurero
";
jugador_principal@nivel = 25;
jugador_principal@salud = 95.5;
jugador_principal@posicion@x = 100;
jugador_principal@posicion@y = 64;
jugador_principal@posicion@z = -50;
walk i set 0 to 4 craft
PolloCrudo
Spider nombre_jugador = "
Jugador_
" bind i;
Stack nivel_inicial = 1 + i * 5;
Ghast salud_inicial = 20.0 :+ (i :* 5.0);
ender_pearl inicializarJugador(jugadores[i], nombre_jugador, nivel_inicial, salud_inicial);
PolloAsado
dropperSpider("
Realizando
operaciones
mezcladas
.
.
.
");
contador = 0;
suma = 0;
producto = 1;
resultado_texto = "
";
walk iteracion set 0 to ITERATIONS - 1 craft
PolloCrudo
Stack indice = iteracion % ARRAY_SIZE;
suma += numeros[indice];
target producto < 1000000 craft hit
PolloCrudo
producto *= (indice + 1);
PolloAsado
Ghast valor_real = valores_reales[indice];
resultado_flotante = resultado_flotante :+ valor_real;
target resultado_flotante :> 1000.0 craft hit
PolloCrudo
resultado_flotante = resultado_flotante :% 1000.0;
PolloAsado
Spider texto_iteracion = textos[iteracion % 10];
target iteracion % 5 is 0 craft hit
PolloCrudo
resultado_texto = resultado_texto bind texto_iteracion;
PolloAsado
target iteracion % 2 is 0 craft hit
PolloCrudo
caracter = etchUp(caracter);
PolloAsado
miss
PolloCrudo
caracter = etchDown(caracter);
PolloAsado
condicion = condicion xor (iteracion % 3 is 0);
target indice % 2 is 0 and condicion craft hit
PolloCrudo
soulsand contador;
PolloAsado
target iteracion % 10 is 0 craft hit
PolloCrudo
Stack danio = calcularDanio(jugador_principal@nivel, 1.5);
Ghast distancia = distanciaEntre(jugador_principal@posicion, origen);
dropperSpider("
Iteración
" bind iteracion bind "
:
Daño
=
" bind danio bind "
,
Distancia
=
" bind distancia);
PolloAsado
Stack jugador_indice = iteracion % 5;
soulsand jugadores[jugador_indice]@nivel;
target iteracion % 20 is 0 craft hit
PolloCrudo
ender_pearl mostrarEstadisticas(jugadores[jugador_indice]);
PolloAsado
PolloAsado
dropperSpider("
Prueba
completada
.
Resultados
:
");
dropperSpider("
Suma
total
:
" bind suma);
dropperSpider("
Producto
acumulado
:
" bind producto);
dropperSpider("
Resultado
flotante
:
" bind resultado_flotante);
dropperSpider("
Texto
resultante
:
" bind resultado_texto);
dropperSpider("
Caracter
final
:
" bind caracter);
dropperSpider("
Contador
incrementado
:
" bind contador);
dropperSpider("
Estado
de
condición
final
:
" bind condicion);
ender_pearl procesarInventario(jugador_principal@inventario);
dropperSpider("
Prueba
de
rendimiento
con
tokens
variados
finalizada
");
worldSave
$*
Prueba_PR_Estructura.ne
Propósito: Verificar el reconocimiento de palabras reservadas de estructura del programa
Probar: WorldName, Bedrock, ResourcePack, Inventory, Recipe, CraftingTable, SpawnPoint
Fecha: 28/04/2025
*$
$$ Prueba de la estructura básica del programa NotchEngine
$$ Verificando las palabras reservadas: WorldName, Bedrock, ResourcePack, Inventory, Recipe, CraftingTable, SpawnPoint
WorldName PruebaEstructura:
Bedrock
Obsidian Stack MAX_VALOR 100;
Obsidian Spider SALUDO "
Prueba
de
estructura
";
ResourcePack
Anvil Stack -> Spider;
Inventory
Stack contador = 0;
Spider mensaje = "
Hola
mundo
";
Recipe
Spell sumar(Stack :: a, b) -> Stack;
Ritual mostrarMensaje(Spider :: texto);
CraftingTable
Spell sumar(Stack :: a, b) -> Stack
PolloCrudo
Stack resultado = a + b;
respawn resultado;
PolloAsado
Ritual mostrarMensaje(Spider :: texto)
PolloCrudo
dropperSpider(texto);
PolloAsado
SpawnPoint
PolloCrudo
dropperSpider(SALUDO);
Stack resultado = sumar(5, 10);
dropperSpider("
El
resultado
es
:
" bind resultado);
PolloAsado
worldSave
$*
Prueba_PR_Tipos.ne
Propósito: Verificar reconocimiento de tipos de datos en NotchEngine
Probar: Stack, Rune, Spider, Torch, Chest, Book, Ghast, Shelf, Entity
Fecha: 28/04/2025
*$
$$ Prueba de los tipos de datos en NotchEngine
$$ Verificando: Stack, Rune, Spider, Torch, Chest, Book, Ghast, Shelf, Entity
WorldName PruebaTipos:
Inventory
$$ Declaraciones de variables de cada tipo
$$ Stack - Tipo de dato entero
Stack entero = 42;
$$ Rune - Tipo de dato carácter
Rune caracter = 'N';
$$ Spider - Tipo de dato string
Spider texto = "
NotchEngine
";
$$ Torch - Tipo de dato booleano
Torch verdadero = On;
Torch falso = Off;
$$ Chest - Tipo de dato conjunto
Chest numeros = {: 1, 2, 3, 4, 5 :};
$$ Book - Tipo de dato archivo de texto
Book archivo = {/ "
datos
.
txt
", 'E' /};
$$ Ghast - Tipo de datos números flotantes
Ghast decimal = 3.14159;
$$ Shelf - Tipo de dato arreglos
Shelf[5] Stack arreglo = [1, 2, 3, 4, 5];
$$ Entity - Tipo de dato registros
Entity Jugador
PolloCrudo
Spider nombre;
Stack nivel;
Ghast salud;
PolloAsado;
Entity Jugador jugador = {nombre: "
Steve
", nivel: 1, salud: 20.0};
SpawnPoint
PolloCrudo
dropperSpider("
Prueba
de
tipos
completada
");
PolloAsado
worldSave
$*
Prueba_PR_Booleanos.ne
Propósito: Verificar reconocimiento de literales booleanas (On, Off)
Probar: Torch, And, Or, Not
Fecha: 28/04/2025
*$
$$ Prueba de literales booleanas en NotchEngine
$$ Verificando: On, Off
WorldName PruebaBooleanos:
Bedrock
Obsidian Torch VERDADERO On;
Obsidian Torch FALSO Off;
Inventory
$$ Declaración e inicialización con valores booleanos
Torch activo = On;
Torch inactivo = Off;
$$ Variables para almacenar resultados de operaciones lógicas
Torch resultado1;
Torch resultado2;
Torch resultado3;
Torch resultado4;
Torch resultado5;
SpawnPoint
PolloCrudo
$$ Mostrar valores booleanos directos
dropperSpider("
Valor
de
On
:
");
dropperTorch(On);
dropperSpider("
Valor
de
Off
:
");
dropperTorch(Off);
$$ Operaciones lógicas con literales booleanas
resultado1 = On and On;
dropperSpider("
On
and
On
:
");
dropperTorch(resultado1);
resultado2 = On and Off;
dropperSpider("
On
and
Off
:
");
dropperTorch(resultado2);
resultado3 = On or Off;
dropperSpider("
On
or
Off
:
");
dropperTorch(resultado3);
resultado4 = Off or Off;
dropperSpider("
Off
or
Off
:
");
dropperTorch(resultado4);
resultado5 = not On;
dropperSpider("
not
On
:
");
dropperTorch(resultado5);
$$ Uso en estructuras de control
target On craft hit
PolloCrudo
dropperSpider("
Condición
On
es
verdadera
");
PolloAsado
target Off craft hit
PolloCrudo
dropperSpider("
Esto
no
debería
mostrarse
");
PolloAsado
miss
PolloCrudo
dropperSpider("
Condición
Off
es
falsa
");
PolloAsado
PolloAsado
worldSave
$*
Prueba_PR_Bloques.ne
Propósito: Verificar reconocimiento de delimitadores de bloques (PolloCrudo, PolloAsado)
Probar: PolloCrudo, PolloAsado
Fecha: 28/04/2025
*$
$$ Prueba de delimitadores de bloques en NotchEngine
$$ Verificando: PolloCrudo, PolloAsado
WorldName PruebaBloques:
Inventory
$$ Variables para las pruebas
Stack contador = 0;
Stack acumulador = 0;
Stack resultado = 0;
Spider mensaje = "
Prueba
de
bloques
PolloCrudo
y
PolloAsado
";
CraftingTable
$$ Función con bloques de código
Spell sumarPares(Stack :: limite) -> Stack
PolloCrudo
Stack suma = 0;
$$ Bloque anidado dentro de una estructura de control
walk i set 1 to limite craft
PolloCrudo
target i % 2 is 0 craft hit
PolloCrudo
suma += i;
PolloAsado
PolloAsado
respawn suma;
PolloAsado
$$ Función con diferentes niveles de anidamiento de bloques
Spell calcularFactorial(Stack :: n) -> Stack
PolloCrudo
target n <= 1 craft hit
PolloCrudo
respawn 1;
PolloAsado
$$ Bloque dentro de una expresión
Stack resultado = n * calcularFactorial(n - 1);
respawn resultado;
PolloAsado
SpawnPoint
$$ Bloque principal
PolloCrudo
$$ Bloque simple
PolloCrudo
contador = 5;
dropperSpider(mensaje);
PolloAsado
$$ Bloque dentro de una estructura repeater
repeater contador > 0 craft
PolloCrudo
acumulador += contador;
magma contador;
$$ Bloque anidado dentro de un condicional dentro de un bucle
target contador is 2 craft hit
PolloCrudo
dropperSpider("
Contador
es
igual
a
2
");
$$ Otro bloque más anidado
PolloCrudo
dropperSpider("
Este
es
un
bloque
muy
anidado
");
PolloAsado
PolloAsado
PolloAsado
$$ Uso de bloques en estructura condicional
target acumulador > 10 craft hit
PolloCrudo
dropperSpider("
Acumulador
es
mayor
que
10
");
PolloAsado
miss
PolloCrudo
dropperSpider("
Acumulador
es
menor
o
igual
a
10
");
PolloAsado
$$ Bloque en estructura spawner-exhausted
spawner
PolloCrudo
soulsand resultado;
target resultado > 5 craft hit creeper;
PolloAsado
exhausted resultado > 10;
dropperSpider("
Valor
final
del
resultado
:
" bind resultado);
PolloAsado
worldSave
$*
Prueba_PR_Control.ne
Propósito: Verificar reconocimiento de palabras de control de flujo
Probar: Entity, PolloCrudo, PolloAsado, Punto, SpawnPoint, Inventory, WorldName
Fecha: 28/04/2025
*$
$$ Prueba de palabras reservadas de control de flujo en NotchEngine
$$ Verificando: repeater, craft, target, hit, miss, jukebox, disc, silence,
$$ spawner, exhausted, walk, set, to, step, wither
WorldName PruebaControl:
Inventory
$$ Variables para las pruebas
Stack contador = 0;
Stack opcion = 2;
Torch condicion = On;
Stack iterador = 0;
Entity Punto
PolloCrudo
Stack x;
Stack y;
PolloAsado;
Entity Punto coordenada;
SpawnPoint
PolloCrudo
$$ 1. Prueba de repeater (while) con craft
dropperSpider("
Prueba
de
repeater
:
");
contador = 5;
repeater contador > 0 craft
PolloCrudo
dropperStack(contador);
magma contador;
PolloAsado
$$ 2. Prueba de target (if) con hit y miss
dropperSpider("
Prueba
de
target
con
hit
y
miss
:
");
target condicion craft hit
PolloCrudo
dropperSpider("
Condición
es
verdadera
");
PolloAsado
miss
PolloCrudo
dropperSpider("
Condición
es
falsa
");
PolloAsado
$$ 3. Prueba de jukebox (switch) con disc y silence
dropperSpider("
Prueba
de
jukebox
con
disc
y
silence
:
");
jukebox opcion craft
disc 1:
PolloCrudo
dropperSpider("
Opción
1
seleccionada
");
PolloAsado
disc 2:
PolloCrudo
dropperSpider("
Opción
2
seleccionada
");
PolloAsado
silence:
PolloCrudo
dropperSpider("
Ninguna
opción
válida
seleccionada
");
PolloAsado
$$ 4. Prueba de spawner (do-while) con exhausted
dropperSpider("
Prueba
de
spawner
con
exhausted
:
");
contador = 0;
spawner
PolloCrudo
soulsand contador;
dropperStack(contador);
PolloAsado
exhausted contador >= 3;
$$ 5. Prueba de walk (for) con set, to, step
dropperSpider("
Prueba
de
walk
con
set
,
to
,
step
:
");
walk i set 0 to 10 step 2 craft
PolloCrudo
dropperStack(i);
PolloAsado
$$ 6. Prueba de wither (with)
dropperSpider("
Prueba
de
wither
:
");
coordenada@x = 10;
coordenada@y = 20;
wither coordenada craft
PolloCrudo
dropperSpider("
Coordenadas
:
(
" bind x bind "
,
" bind y bind "
)
");
PolloAsado
PolloAsado
worldSave
$*
Prueba_PR_Saltos.ne
Propósito: Verificar palabras para saltos y terminación (creeper, enderPearl, ragequit)
Fecha: 28/04/2025
*$
$$ Prueba de palabras reservadas para saltos y terminación en NotchEngine
$$ Verificando: creeper, enderPearl, ragequit
WorldName PruebaSaltos:
Inventory
$$ Variables para las pruebas
Stack contador = 0;
Stack totalPares = 0;
Stack totalImpares = 0;
Torch errorCritico = Off;
SpawnPoint
PolloCrudo
$$ 1. Prueba de creeper (break) para salir de un bucle
dropperSpider("
Prueba
de
creeper
(
break
)
:
");
walk i set 1 to 10 craft
PolloCrudo
dropperSpider("
Iteración
:
" bind i);
$$ Salimos del bucle cuando i llega a 5
target i is 5 craft hit
PolloCrudo
dropperSpider("
Encontrado
5
,
saliendo
del
bucle
con
creeper
");
creeper;
PolloAsado
PolloAsado
$$ 2. Prueba de enderPearl (continue) para saltar a la siguiente iteración
dropperSpider("
Prueba
de
enderPearl
(
continue
)
:
");
walk i set 1 to 10 craft
PolloCrudo
$$ Saltamos los números pares
target i % 2 is 0 craft hit
PolloCrudo
dropperSpider("
Número
par
" bind i bind "
,
saltando
con
enderPearl
");
enderPearl;
PolloAsado
$$ Esta parte solo se ejecuta para números impares
dropperSpider("
Procesando
número
impar
:
" bind i);
totalImpares += i;
PolloAsado
dropperSpider("
Total
de
números
impares
:
" bind totalImpares);
$$ 3. Prueba de creeper y enderPearl en bucles anidados
dropperSpider("
Prueba
de
control
de
flujo
en
bucles
anidados
:
");
walk i set 1 to 5 craft
PolloCrudo
walk j set 1 to 5 craft
PolloCrudo
$$ Saltar la iteración cuando j es 3
target j is 3 craft hit
PolloCrudo
dropperSpider("
Saltando
j
=
3
con
enderPearl
");
enderPearl;
PolloAsado
$$ Salir del bucle interno cuando j es 4
target j is 4 craft hit
PolloCrudo
dropperSpider("
Saliendo
del
bucle
interno
con
creeper
en
j
=
4
");
creeper;
PolloAsado
dropperSpider("
i
=
" bind i bind "
,
j
=
" bind j);
PolloAsado
PolloAsado
$$ 4. Prueba de ragequit (halt) para terminar el programa
$$ Nota: Esta parte debe estar comentada en pruebas reales
$$ o al final del programa, ya que detiene la ejecución
dropperSpider("
Prueba
de
ragequit
(
halt
)
:
");
target errorCritico craft hit
PolloCrudo
dropperSpider("
Error
crítico
detectado
,
terminando
programa
con
ragequit
");
$$ ragequit; $$ Comentado para evitar terminar la prueba
PolloAsado
dropperSpider("
Esta
línea
se
mostrará
si
errorCritico
es
Off
");
$$ Ejemplo descomentado pero que nunca se ejecutará
target Off craft hit
PolloCrudo
dropperSpider("
Esta
condición
nunca
se
cumple
");
ragequit;
PolloAsado
PolloAsado
worldSave
$*
Prueba_PR_Funciones.ne
Propósito: Verificar palabras para funciones y procedimientos (Spell, Ritual, respawn, ender_pearl)
Probar: Spell, Ritual, respawn, ender_pearl, crafting_table
Fecha: 28/04/2025
*$
$$ Prueba de palabras reservadas para funciones y procedimientos en NotchEngine
$$ Verificando: Spell, Ritual, respawn
WorldName PruebaFunciones:
$$ Sección de prototipos
Recipe
$$ Prototipos de funciones (Spell)
Spell sumar(Stack :: a, b) -> Stack;
Spell factorial(Stack :: n) -> Stack;
Spell esPar(Stack :: numero) -> Torch;
Spell sumarArreglo(Shelf[10] Stack :: numeros; Stack tamano) -> Stack;
$$ Prototipos de procedimientos (Ritual)
Ritual imprimirLinea(Spider :: texto);
Ritual mostrarResultado(Spider :: operacion; Stack valor);
Ritual imprimirArreglo(Shelf[10] Stack :: arr; Stack tamano);
$$ Sección de rutinas (implementación de funciones y procedimientos)
CraftingTable
$$ Funciones (Spell) con instrucción de retorno (respawn)
Spell sumar(Stack :: a, b) -> Stack
PolloCrudo
$$ Retorno con expresión simple
respawn a + b;
PolloAsado
Spell factorial(Stack :: n) -> Stack
PolloCrudo
$$ Retorno temprano con condición
target n <= 1 craft hit
PolloCrudo
respawn 1;
PolloAsado
$$ Retorno con expresión compleja y llamada recursiva
respawn n * factorial(n - 1);
PolloAsado
Spell esPar(Stack :: numero) -> Torch
PolloCrudo
target numero % 2 is 0 craft hit
PolloCrudo
respawn On;
PolloAsado
miss
PolloCrudo
respawn Off;
PolloAsado
PolloAsado
Spell sumarArreglo(Shelf[10] Stack :: numeros; Stack tamano) -> Stack
PolloCrudo
Stack suma = 0;
$$ Verificar parámetros
target tamano <= 0 craft hit
PolloCrudo
respawn 0; $$ Retorno temprano
PolloAsado
$$ Sumar elementos del arreglo
walk i set 0 to tamano - 1 craft
PolloCrudo
suma += numeros[i];
PolloAsado
respawn suma; $$ Retorno al final
PolloAsado
$$ Procedimientos (Ritual) con posibles retornos vacíos
Ritual imprimirLinea(Spider :: texto)
PolloCrudo
dropperSpider(texto);
dropperSpider("
--
--
--
--
--
--
--
--
--
--
--
--
");
PolloAsado
Ritual mostrarResultado(Spider :: operacion; Stack valor)
PolloCrudo
dropperSpider(operacion bind "
:
" bind valor);
$$ Retorno temprano sin valor
target valor < 0 craft hit
PolloCrudo
dropperSpider("
Valor
negativo
");
respawn; $$ Retorno vacío temprano
PolloAsado
dropperSpider("
Valor
válido
procesado
");
PolloAsado
Ritual imprimirArreglo(Shelf[10] Stack :: arr; Stack tamano)
PolloCrudo
target tamano <= 0 craft hit
PolloCrudo
dropperSpider("
Arreglo
vacío
");
respawn; $$ Retorno vacío temprano
PolloAsado
dropperSpider("
Elementos
del
arreglo
:
");
walk i set 0 to tamano - 1 craft
PolloCrudo
dropperStack(arr[i]);
PolloAsado
PolloAsado
$$ Punto de entrada con llamadas a funciones y procedimientos
SpawnPoint
PolloCrudo
$$ Declaración de variables
Stack a = 5;
Stack b = 7;
Stack resultado;
Shelf[10] Stack numeros;
$$ Inicializar arreglo
walk i set 0 to 9 craft
PolloCrudo
numeros[i] = i + 1;
PolloAsado
$$ Llamadas a funciones (invocación directa)
resultado = sumar(a, b);
dropperSpider("
Suma
:
" bind resultado);
resultado = factorial(5);
dropperSpider("
Factorial
de
5
:
" bind resultado);
Torch esPar5 = esPar(5);
dropperSpider("
Es
5
par
:
");
dropperTorch(esPar5);
resultado = sumarArreglo(numeros, 10);
dropperSpider("
Suma
del
arreglo
:
" bind resultado);
$$ Llamadas a procedimientos
imprimirLinea("
==
==
Resultados
de
pruebas
==
==
");
mostrarResultado("
Suma
de
5
y
7
", sumar(a, b));
mostrarResultado("
Valor
negativo
", -10);
imprimirArreglo(numeros, 5);
imprimirArreglo(numeros, 0);
PolloAsado
worldSave
$*
Prueba_PR_Operadores.ne
Propósito: Verificar operadores textuales reales en Notch Engine
Probar: soulsand, magma, and, or, not, xor, bind, #, from ##, except ##, seek,
add, drop, feed, map, biom, void, isEngraved, isInscribed, etchUp, etchDown,
unlock, lock, make, gather, forge, expand
Fecha: 28/04/2025
*$
WorldName PruebaOperadores:
Inventory {
Stack contador = 5; $$ Inicializa contador con 5
Torch condicion1 = On; $$ Condición 1 es verdadera
Torch condicion2 = Off; $$ Condición 2 es falsa
Torch resultado; $$ Variable para almacenar resultados booleanos
Spider texto1 = "
Notch
"; $$ Texto inicial "
Notch
"
Spider texto2 = "
Engine
"; $$ Texto inicial "
Engine
"
Spider textoCompleto; $$ Variable para texto combinado
Rune letra = 'a'; $$ Letra inicial 'a'
Rune letraMayuscula; $$ Variable para letra mayúscula
Chest conjunto1 = {: 1, 2, 3 :}; $$ Conjunto inicial con 1, 2, 3
Chest conjunto2 = {: 3, 4, 5 :}; $$ Conjunto inicial con 3, 4, 5
Chest conjuntoResultado; $$ Variable para resultado de conjuntos
Book archivo1 = {/ "
datos
.
txt
", 'E' /}; $$ Archivo para escritura "
datos
.
txt
"
Book archivo2 = {/ "
resultado
.
txt
", 'E' /}; $$ Archivo para escritura "
resultado
.
txt
"
Ghast flotante1 = 3.5; $$ Flotante inicial 3.5
Ghast flotante2 = 2.5; $$ Flotante inicial 2.5
Ghast resultadoFlotante; $$ Variable para resultado de operaciones flotantes
}
SpawnPoint {
PolloCrudo
$$ soulsand y magma
soulsand contador; $$ Aplica soulsand a contador
magma contador; $$ Aplica magma a contador
$$ and, or, not, xor
resultado = condicion1 and condicion2; $$ Resultado es verdadero si ambas condiciones son verdaderas
resultado = condicion1 or condicion2; $$ Resultado es verdadero si al menos una condición es verdadera
resultado = not condicion1; $$ Resultado es el opuesto de condicion1
resultado = condicion1 xor condicion2; $$ Resultado es verdadero si solo una condición es verdadera
$$ bind, #, from ##, except ##, seek
textoCompleto = bind(texto1, "
" bind texto2); $$ Combina texto1 y texto2 con un espacio
Stack longitud = #(textoCompleto); $$ Longitud de textoCompleto
Spider subcadena = from textoCompleto ## 0 ## 5; $$ Subcadena de textoCompleto desde 0 hasta 5
Spider sinNotch = except textoCompleto ## 0 ## 6; $$ Elimina caracteres de 0 a 6 en textoCompleto
Stack posicion = seek(textoCompleto, "
Engine
"); $$ Posición de "
Engine
" en textoCompleto
$$ isEngraved, isInscribed, etchUp, etchDown
Torch esLetra = isEngraved(letra); $$ Verifica si letra es una letra
Torch esDigito = isInscribed(letra); $$ Verifica si letra es un dígito
letraMayuscula = etchUp(letra); $$ Convierte letra a mayúscula
Rune letraMinuscula = etchDown(letraMayuscula); $$ Convierte letraMayuscula a minúscula
$$ Operaciones de conjuntos
add(conjunto1, 4); $$ Añade 4 a conjunto1
drop(conjunto1, 2); $$ Elimina 2 de conjunto1
conjuntoResultado = feed(conjunto1, conjunto2); $$ Intersección de conjunto1 y conjunto2
resultado = map(conjunto1, 3); $$ Verifica si 3 está en conjunto1
Torch conjuntoVacio = void(conjunto1); $$ Verifica si conjunto1 está vacío
$$ Operaciones de archivos
unlock(archivo1); $$ Abre archivo1 para escritura
forge(archivo1, "
Texto
de
prueba
"); $$ Escribe "
Texto
de
prueba
" en archivo1
lock(archivo1); $$ Cierra archivo1
Book nuevoArchivo = make({/ "
nuevo
.
txt
", 'E' /}); $$ Crea nuevo archivo "
nuevo
.
txt
"
forge(nuevoArchivo, "
Contenido
del
nuevo
archivo
"); $$ Escribe en nuevoArchivo
lock(nuevoArchivo); $$ Cierra nuevoArchivo
unlock(archivo1); $$ Abre archivo1
unlock(nuevoArchivo); $$ Abre nuevoArchivo
expand(archivo1, nuevoArchivo); $$ Expande archivo1 con contenido de nuevoArchivo
lock(archivo1); $$ Cierra archivo1
lock(nuevoArchivo); $$ Cierra nuevoArchivo
$$ Operadores de flotantes
resultadoFlotante = flotante1 :+ flotante2; $$ Suma de flotante1 y flotante2
resultadoFlotante = flotante1 :- flotante2; $$ Resta de flotante1 y flotante2
resultadoFlotante = flotante1 :* flotante2; $$ Multiplicación de flotante1 y flotante2
resultadoFlotante = flotante1 :// flotante2; $$ División de flotante1 y flotante2
resultadoFlotante = flotante1 :% flotante2; $$ Módulo de flotante1 y flotante2
PolloAsado
}
worldSave
$*
Prueba_Lit_Enteros.ne
Propósito: Verificar reconocimiento de literales enteros (positivos, negativos, cero)
Probar: Stack
Fecha: 28/04/2025
*$
$$ Prueba de literales enteros en NotchEngine
$$ Verificando: enteros positivos, negativos y cero
WorldName PruebaLitEnteros:
Bedrock
$$ Constantes enteras
Obsidian Stack CERO 0;
Obsidian Stack POSITIVO 42;
Obsidian Stack NEGATIVO -42;
Obsidian Stack MAX_VALOR 2147483647; $$ Valor máximo de 32 bits
Obsidian Stack MIN_VALOR -2147483648; $$ Valor mínimo de 32 bits
Inventory
$$ Variables con literales enteros
Stack cero = 0;
Stack uno = 1;
Stack diez = 10;
Stack cien = 100;
Stack mil = 1000;
Stack millon = 1000000;
$$ Enteros negativos
Stack negUno = -1;
Stack negDiez = -10;
Stack negCien = -100;
Stack negMil = -1000;
Stack negMillon = -1000000;
$$ Valor entero máximo y mínimo (aproximadamente)
Stack maxInt = 2147483647;
Stack minInt = -2147483648;
$$ Variables para resultados
Stack resultado = 0;
SpawnPoint
PolloCrudo
$$ Operaciones aritméticas con literales enteros directos
resultado = 5 + 3; $$ 8
dropperSpider("
5
+
3
=
" bind resultado);
resultado = 10 - 7; $$ 3
dropperSpider("
10
-
7
=
" bind resultado);
resultado = 6 * 4; $$ 24
dropperSpider("
6
*
4
=
" bind resultado);
resultado = 20 // 4; $$ 5
dropperSpider("
20
4
=
" bind resultado);
resultado = 17 % 5; $$ 2
dropperSpider("
17
%
5
=
" bind resultado);
$$ Uso de literales enteros en expresiones complejas
resultado = (5 + 3) * 2 - 4 // 2; $$ 16 - 2 = 14
dropperSpider("
(
5
+
3
)
*
2
-
4
2
=
" bind resultado);
$$ Operaciones con literales enteros negativos
resultado = -5 + 10; $$ 5
dropperSpider("
-
5
+
10
=
" bind resultado);
resultado = 5 + -10; $$ -5
dropperSpider("
5
+
-
10
=
" bind resultado);
resultado = -5 * -4; $$ 20
dropperSpider("
-
5
*
-
4
=
" bind resultado);
$$ Uso de literales enteros en estructuras de control
walk i set 1 to 5 craft
PolloCrudo
dropperSpider("
Iteración
:
" bind i);
PolloAsado
$$ Comparaciones con literales enteros
target 10 > 5 craft hit
PolloCrudo
dropperSpider("
10
es
mayor
que
5
");
PolloAsado
target 0 is 0 craft hit
PolloCrudo
dropperSpider("
0
es
igual
a
0
");
PolloAsado
target -10 < -5 craft hit
PolloCrudo
dropperSpider("
-
10
es
menor
que
-
5
");
PolloAsado
$$ Operaciones con valores extremos (cuidado con overflow)
dropperSpider("
Valor
máximo
de
entero
:
" bind maxInt);
dropperSpider("
Valor
mínimo
de
entero
:
" bind minInt);
$$ Verificación del cero
target 0 is cero craft hit
PolloCrudo
dropperSpider("
Ambas
representaciones
de
cero
son
iguales
");
PolloAsado
PolloAsado
worldSave
$*
Prueba_Lit_Flotantes.ne
Propósito: Verificar reconocimiento de números flotantes (con parte decimal, sin parte decimal, negativos)
Probar: Ghast
Fecha: 28/04/2025
*$
$$ Prueba de literales flotantes en NotchEngine
$$ Verificando: flotantes con parte decimal, sin parte decimal, y negativos
WorldName PruebaLitFlotantes:
Bedrock
$$ Constantes flotantes
Obsidian Ghast CERO_PUNTO_CERO 0.0;
Obsidian Ghast PI 3.14159;
Obsidian Ghast E 2.71828;
Obsidian Ghast NEG_PI -3.14159;
Obsidian Ghast GRAVEDAD -9.8;
Inventory
$$ Flotantes positivos con parte decimal
Ghast decimal1 = 0.5;
Ghast decimal2 = 1.25;
Ghast decimal3 = 3.14159;
Ghast decimal4 = 2.71828;
Ghast decimal5 = 123.456;
$$ Flotantes negativos con parte decimal
Ghast negDecimal1 = -0.5;
Ghast negDecimal2 = -1.25;
Ghast negDecimal3 = -3.14159;
Ghast negDecimal4 = -2.71828;
Ghast negDecimal5 = -123.456;
$$ Formas alternativas (punto al principio, sin parte decimal)
Ghast decimal6 = .5; $$ Sin cero al principio, comienza con punto
Ghast decimal7 = 5.; $$ Sin decimales, termina con punto
$$ Números con muchos decimales
Ghast precisionAlta = 1.123456789012345;
$$ Números muy pequeños y muy grandes
Ghast muyPequeno = 0.0000001;
Ghast muyGrande = 1000000.0;
$$ Variables para resultados
Ghast resultado = 0.0;
SpawnPoint
PolloCrudo
$$ Operaciones aritméticas con literales flotantes directos
resultado = 5.5 :+ 3.5; $$ 9.0
dropperSpider("
5.5
:
+
3.5
=
");
dropperGhast(resultado);
resultado = 10.75 :- 7.25; $$ 3.5
dropperSpider("
10.75
:
-
7.25
=
");
dropperGhast(resultado);
resultado = 6.5 :* 2.0; $$ 13.0
dropperSpider("
6.5
:
*
2.0
=
");
dropperGhast(resultado);
resultado = 20.0 :// 4.0; $$ 5.0
dropperSpider("
20.0
:
4.0
=
");
dropperGhast(resultado);
resultado = 7.5 :% 2.0; $$ 1.5
dropperSpider("
7.5
:
%
2.0
=
");
dropperGhast(resultado);
$$ Uso de notaciones decimales alternativas
resultado = .5 :+ 2.; $$ 0.5 + 2.0 = 2.5
dropperSpider("
.
5
:
+
2
.
=
");
dropperGhast(resultado);
$$ Operaciones con literales flotantes negativos
resultado = -5.5 :+ 10.0; $$ 4.5
dropperSpider("
-
5.5
:
+
10.0
=
");
dropperGhast(resultado);
resultado = 5.0 :+ -10.0; $$ -5.0
dropperSpider("
5.0
:
+
-
10.0
=
");
dropperGhast(resultado);
resultado = -5.0 :* -4.0; $$ 20.0
dropperSpider("
-
5.0
:
*
-
4.0
=
");
dropperGhast(resultado);
$$ Expresiones complejas con flotantes
resultado = (2.5 :+ 1.5) :* 3.0 :- 5.0 :// 2.0; $$ 12.0 - 2.5 = 9.5
dropperSpider("
(
2.5
:
+
1.5
)
:
*
3.0
:
-
5.0
:
2.0
=
");
dropperGhast(resultado);
$$ Comparaciones con flotantes
target 3.14 > 3.0 craft hit
PolloCrudo
dropperSpider("
3.14
es
mayor
que
3.0
");
PolloAsado
target 0.1 :+ 0.2 isNot 0.3 craft hit $$ Debido a errores de precisión en flotantes
PolloCrudo
dropperSpider("
0.1
+
0.2
no
es
exactamente
igual
a
0.3
(
error
de
precisión
)
");
dropperGhast(0.1 :+ 0.2);
PolloAsado
$$ Conversión y coherción de tipos
Stack entero = 3.14159 >> Stack; $$ Cohersión a entero (trunca a 3)
dropperSpider("
PI
truncado
a
entero
:
" bind entero);
$$ Mostrar valores con diferentes precisiones
dropperSpider("
Valor
de
PI
:
");
dropperGhast(PI);
dropperSpider("
Número
con
alta
precisión
:
");
dropperGhast(precisionAlta);
dropperSpider("
Número
muy
pequeño
:
");
dropperGhast(muyPequeno);
dropperSpider("
Número
muy
grande
:
");
dropperGhast(muyGrande);
PolloAsado
worldSave
$*
Prueba_Lit_Caracteres.ne
Propósito: Verificar reconocimiento de caracteres (letras, dígitos, símbolos, escapes)
Probar: Rune, dropperRune, dropperSpider, dropperTorch
Fecha: 28/04/2025
*$
$$ Prueba de literales de caracteres en NotchEngine
$$ Verificando: letras, dígitos, símbolos y secuencias de escape
WorldName PruebaLitCaracteres:
Bedrock
$$ Constantes de caracteres
Obsidian Rune LETRA_A 'A';
Obsidian Rune LETRA_Z 'Z';
Obsidian Rune DIGITO_0 '0';
Obsidian Rune DIGITO_9 '9';
Obsidian Rune NUEVA_LINEA '\n';
Obsidian Rune TABULACION '\t';
Inventory
$$ Letras mayúsculas
Rune letraA = 'A';
Rune letraB = 'B';
Rune letraC = 'C';
Rune letraZ = 'Z';
$$ Letras minúsculas
Rune letraMina = 'a';
Rune letraMinb = 'b';
Rune letraMinc = 'c';
Rune letraMinz = 'z';
$$ Dígitos
Rune digito0 = '0';
Rune digito1 = '1';
Rune digito5 = '5';
Rune digito9 = '9';
$$ Símbolos comunes
Rune simboloExclamacion = '!';
Rune simboloInterrogacion = '?';
Rune simboloArroba = '@';
Rune simboloNumeral = '#';
Rune simboloDolar = '$';
Rune simboloPorcentaje = '%';
Rune simboloAmpersand = '&';
Rune simboloAsterisco = '*';
Rune simboloParentesisIzq = '(';
Rune simboloParentesisDer = ')';
Rune simboloGuion = '-';
Rune simboloGuionBajo = '_';
Rune simboloIgual = '=';
Rune simboloMas = '+';
Rune simboloCorcheteIzq = '[';
Rune simboloCorcheteDer = ']';
Rune simboloLlaveIzq = '{';
Rune simboloLlaveDer = '}';
Rune simboloPuntoyComa = ';';
Rune simboloDosPuntos = ':';
Rune simboloComillaSimple = '\'';
Rune simboloComillaDoble = '"
';
Rune simboloBarra = '
';
Rune simboloBarraInversa = '
';
Rune simboloBarraVertical = '
';
Rune simboloComa = '
,
';
Rune simboloPunto = '
.
';
Rune simboloMenorQue = '
<
';
Rune simboloMayorQue = '
>
';
$$ Secuencias de escape
Rune escapeNuevaLinea = '
n
';
Rune escapeTabulacion = '
t
';
Rune escapeRetornoCarro = '
r
';
Rune escapeBarraInversa = '
';
Rune escapeComillaSimple = '
''
;
Rune
escapeComillaDoble
=
'\"'
;
SpawnPoint
PolloCrudo
dropperSpider
(
"Letras mayúsculas: "
)
;
dropperRune
(
letraA
)
;
dropperRune
(
letraB
)
;
dropperRune
(
letraC
)
;
dropperSpider
(
"Letras minúsculas: "
)
;
dropperRune
(
letraMina
)
;
dropperRune
(
letraMinb
)
;
dropperRune
(
letraMinc
)
;
dropperSpider
(
"Dígitos: "
)
;
dropperRune
(
digito0
)
;
dropperRune
(
digito1
)
;
dropperRune
(
digito5
)
;
dropperRune
(
digito9
)
;
dropperSpider
(
"Símbolos: "
)
;
dropperRune
(
simboloExclamacion
)
;
dropperRune
(
simboloInterrogacion
)
;
dropperRune
(
simboloArroba
)
;
dropperRune
(
simboloNumeral
)
;
Spider
texto
=
"NotchEngine"
;
Rune
primerCaracter
=
texto
[
0
]
;
Rune
ultimoCaracter
=
texto
[
10
]
;
dropperSpider
(
"Primer carácter de 'NotchEngine': "
)
;
dropperRune
(
primerCaracter
)
;
dropperSpider
(
"Último carácter de 'NotchEngine': "
)
;
dropperRune
(
ultimoCaracter
)
;
Rune
letraMinuscula
=
'a'
;
Rune
letraMayuscula
=
etchUp
(
letraMinuscula
)
;
dropperSpider
(
"Minúscula: "
)
;
dropperRune
(
letraMinuscula
)
;
dropperSpider
(
"Convertida a mayúscula: "
)
;
dropperRune
(
letraMayuscula
)
;
letraMinuscula
=
etchDown
(
letraMayuscula
)
;
dropperSpider
(
"Convertida nuevamente a minúscula: "
)
;
dropperRune
(
letraMinuscula
)
;
Torch
esLetra
=
isEngraved
(
'A'
)
;
Torch
esDigito
=
isInscribed
(
'5'
)
;
dropperSpider
(
"¿'A' es una letra? "
)
;
dropperTorch
(
esLetra
)
;
dropperSpider
(
"¿'5' es un dígito? "
)
;
dropperTorch
(
esDigito
)
;
esLetra
=
isEngraved
(
'7'
)
;
esDigito
=
isInscribed
(
'K'
)
;
dropperSpider
(
"¿'7' es una letra? "
)
;
dropperTorch
(
esLetra
)
;
dropperSpider
(
"¿'K' es un dígito? "
)
;
dropperTorch
(
esDigito
)
;
Stack
valorAsciiA
=
letraA
>
>
Stack
;
dropperSpider
(
"Valor ASCII de 'A': "
bind
valorAsciiA
)
;
PolloAsado
worldSave
WorldName
PruebaLitStrings
:
Bedrock
Obsidian
Spider
VACIO
""
;
Obsidian
Spider
ESPACIO
" "
;
Obsidian
Spider
SALUDO
"Hola Mundo"
;
Obsidian
Spider
CON_COMILLAS
"Este string tiene \"comillas\""
;
Obsidian
Spider
MULTILINEA
"Primera línea\nSegunda línea"
;
Inventory
Spider
cadenaVacia
=
""
;
Spider
espacioSimple
=
" "
;
Spider
cadenaSimple
=
"Texto simple"
;
Spider
conNumeros
=
"Notch Engine v1.0"
;
Spider
conSimbolos
=
"¡Hola, mundo! ¿Cómo estás?"
;
Spider
conCaracteresEspeciales
=
"#$%&/()=?¡"
;
Spider
conNuevaLinea
=
"Primera línea\nSegunda línea"
;
Spider
conTabulacion
=
"Columna1\tColumna2\tColumna3"
;
Spider
conRetornoCarro
=
"Texto con\rretorno de carro"
;
Spider
conBarraInversa
=
"Ruta de archivo: C:\\Archivos\\datos.txt"
;
Spider
conComillasSimples
=
"Texto con 'comillas simples'"
;
Spider
conComillasDobles
=
"Texto con \"comillas dobles\""
;
Spider
mixto
=
"Abc123!@#\n\t\"'"
;
Spider
cadenaLarga
=
"Esta es una cadena de texto más larga que contiene múltiples palabras, números como 12345, y símbolos como $%&. Es útil para probar el manejo de cadenas extensas en el analizador léxico y asegurarse de que no hay limitaciones inesperadas en la longitud de las cadenas."
;
Spider
prefijo
=
"Notch"
;
Spider
sufijo
=
"Engine"
;
Spider
resultado
;
SpawnPoint
PolloCrudo
dropperSpider
(
"Cadena simple: "
bind
cadenaSimple
)
;
dropperSpider
(
"Cadena con números: "
bind
conNumeros
)
;
dropperSpider
(
"Cadena con símbolos: "
bind
conSimbolos
)
;
resultado
=
bind
(
prefijo
,
" "
bind
sufijo
)
;
dropperSpider
(
"Concatenación: "
bind
resultado
)
;
Stack
longitud
=
#
(
resultado
)
;
dropperSpider
(
"Longitud de '"
bind
resultado
bind
"': "
bind
longitud
)
;
Spider
subcadena
=
from
resultado
#
#
0
#
#
5
;
dropperSpider
(
"Subcadena (0, 5): "
bind
subcadena
)
;
Spider
sinNotch
=
except
resultado
#
#
0
#
#
6
;
dropperSpider
(
"Sin los primeros 6 caracteres: "
bind
sinNotch
)
;
Stack
posicion
=
seek
(
resultado
,
"Engine"
)
;
dropperSpider
(
"Posición de 'Engine': "
bind
posicion
)
;
Rune
primerCaracter
=
resultado
[
0
]
;
dropperSpider
(
"Primer carácter: "
)
;
dropperRune
(
primerCaracter
)
;
Rune
ultimoCaracter
=
resultado
[
11
]
;
dropperSpider
(
"Último carácter: "
)
;
dropperRune
(
ultimoCaracter
)
;
dropperSpider
(
"Cadena con nueva línea:"
)
;
dropperSpider
(
conNuevaLinea
)
;
dropperSpider
(
"Cadena con tabulaciones:"
)
;
dropperSpider
(
conTabulacion
)
;
dropperSpider
(
"Cadena con comillas dobles:"
)
;
dropperSpider
(
conComillasDobles
)
;
dropperSpider
(
"Cadena larga:"
)
;
dropperSpider
(
cadenaLarga
)
;
target
cadenaVacia
is
""
craft
hit
PolloCrudo
dropperSpider
(
"La cadena está vacía"
)
;
PolloAsado
target
SALUDO
is
"Hola Mundo"
craft
hit
PolloCrudo
dropperSpider
(
"Las cadenas son iguales"
)
;
PolloAsado
PolloAsado
worldSave
WorldName
PruebaLitArreglos
:
Bedrock
Inventory
Shelf
[
5
]
Stack
numerosSimples
=
[
1
,
2
,
3
,
4
,
5
]
;
Shelf
[
3
]
Stack
numerosNegativos
=
[
-
10
,
-
20
,
-
30
]
;
Shelf
[
4
]
Stack
numerosMixtos
=
[
-
2
,
0
,
2
,
4
]
;
Shelf
[
1
]
Stack
unicoElemento
=
[
42
]
;
Shelf
[
0
]
Stack
arregloVacio
=
[
]
;
Shelf
[
5
]
Rune
vocales
=
[
'a'
,
'e'
,
'i'
,
'o'
,
'u'
]
;
Shelf
[
5
]
Rune
simbolos
=
[
'!'
,
'@'
,
'#'
,
'$'
,
'%'
]
;
Shelf
[
3
]
Spider
nombres
=
[
"Steve"
,
"Alex"
,
"Herobrine"
]
;
Shelf
[
4
]
Spider
diasSemana
=
[
"Lunes"
,
"Martes"
,
"Miércoles"
,
"Jueves"
]
;
Shelf
[
4
]
Torch
flags
=
[
On
,
Off
,
On
,
On
]
;
Shelf
[
3
]
Ghast
decimales
=
[
3.14
,
2.71
,
1.618
]
;
Shelf
[
3
]
Shelf
[
3
]
Stack
matriz
=
[
[
1
,
2
,
3
]
,
[
4
,
5
,
6
]
,
[
7
,
8
,
9
]
]
;
Shelf
[
2
]
Shelf
[
2
]
Shelf
[
2
]
Stack
cubo
=
[
[
[
1
,
2
]
,
[
3
,
4
]
]
,
[
[
5
,
6
]
,
[
7
,
8
]
]
]
;
Stack
suma
=
0
;
Stack
elementoActual
=
0
;
SpawnPoint
PolloCrudo
elementoActual
=
numerosSimples
[
0
]
;
dropperSpider
(
"Primer elemento del arreglo: "
bind
elementoActual
)
;
elementoActual
=
numerosSimples
[
4
]
;
dropperSpider
(
"Último elemento del arreglo: "
bind
elementoActual
)
;
numerosSimples
[
2
]
=
30
;
dropperSpider
(
"Elemento modificado: "
bind
numerosSimples
[
2
]
)
;
suma
=
0
;
walk
i
set
0
to
4
craft
PolloCrudo
suma
+
=
numerosSimples
[
i
]
;
dropperSpider
(
"Elemento "
bind
i
bind
": "
bind
numerosSimples
[
i
]
)
;
PolloAsado
dropperSpider
(
"Suma de todos los elementos: "
bind
suma
)
;
dropperSpider
(
"Vocales: "
)
;
walk
i
set
0
to
4
craft
PolloCrudo
dropperRune
(
vocales
[
i
]
)
;
PolloAsado
dropperSpider
(
"Nombres: "
)
;
walk
i
set
0
to
2
craft
PolloCrudo
dropperSpider
(
nombres
[
i
]
)
;
PolloAsado
dropperSpider
(
"Flags: "
)
;
walk
i
set
0
to
3
craft
PolloCrudo
dropperTorch
(
flags
[
i
]
)
;
PolloAsado
dropperSpider
(
"Decimales: "
)
;
walk
i
set
0
to
2
craft
PolloCrudo
dropperGhast
(
decimales
[
i
]
)
;
PolloAsado
elementoActual
=
matriz
[
1
]
[
1
]
;
dropperSpider
(
"Elemento central de la matriz: "
bind
elementoActual
)
;
matriz
[
0
]
[
2
]
=
10
;
dropperSpider
(
"Elemento modificado de la matriz: "
bind
matriz
[
0
]
[
2
]
)
;
dropperSpider
(
"Matriz completa:"
)
;
walk
i
set
0
to
2
craft
PolloCrudo
walk
j
set
0
to
2
craft
PolloCrudo
dropperStack
(
matriz
[
i
]
[
j
]
)
;
PolloAsado
dropperSpider
(
""
)
;
PolloAsado
elementoActual
=
cubo
[
1
]
[
0
]
[
1
]
;
dropperSpider
(
"Elemento de cubo [1][0][1]: "
bind
elementoActual
)
;
Shelf
[
4
]
Stack
fibonacci
=
[
1
,
1
,
2
,
3
]
;
dropperSpider
(
"Fibonacci: "
)
;
walk
i
set
0
to
3
craft
PolloCrudo
dropperStack
(
fibonacci
[
i
]
)
;
PolloAsado
PolloAsado
worldSave
WorldName
PruebaLitRegistros
:
Inventory
Entity
Jugador
PolloCrudo
Spider
nombre
;
Stack
nivel
;
Ghast
salud
;
Torch
activo
;
PolloAsado
;
Entity
Coordenada
PolloCrudo
Stack
x
;
Stack
y
;
Stack
z
;
PolloAsado
;
Entity
Configuracion
PolloCrudo
Torch
modoDebug
;
Stack
volumen
;
Spider
idioma
;
PolloAsado
;
Entity
Jugador
steve
=
{
nombre
:
"Steve"
,
nivel
:
1
,
salud
:
20.0
,
activo
:
On
}
;
Entity
Jugador
alex
=
{
nombre
:
"Alex"
,
nivel
:
2
,
salud
:
18.5
,
activo
:
On
}
;
Entity
Coordenada
posicion
=
{
x
:
10
,
y
:
20
,
z
:
30
}
;
Entity
Configuracion
config
=
{
modoDebug
:
Off
,
volumen
:
75
,
idioma
:
"Español"
}
;
Entity
Jugador
jugadorVacio
=
{
}
;
Entity
Coordenada
origen
=
{
x
:
0
}
;
Entity
Coordenada
punto
=
{
x
:
5
+
5
,
y
:
10
*
2
,
z
:
100
2
}
;
SpawnPoint
PolloCrudo
dropperSpider
(
steve
@
nombre
)
;
dropperStack
(
posicion
@
x
)
;
dropperTorch
(
config
@
modoDebug
)
;
steve
@
nivel
=
5
;
posicion
@
z
=
50
;
Stack
nivelTotal
=
steve
@
nivel
+
alex
@
nivel
;
dropperStack
(
nivelTotal
)
;
wither
steve
craft
PolloCrudo
dropperSpider
(
"Nombre: "
bind
nombre
)
;
dropperStack
(
nivel
)
;
dropperGhast
(
salud
)
;
PolloAsado
Entity
Jugador
herobrine
=
{
nombre
:
"Herobrine"
,
nivel
:
100
,
salud
:
1000.0
,
activo
:
On
}
;
Entity
Coordenada
pos2
=
{
x
:
100
,
y
:
200
,
z
:
300
}
;
PolloAsado
worldSave
WorldName
PruebaLitConjuntos
:
Inventory
Chest
numeros
=
{
:
1
,
2
,
3
,
4
,
5
:
}
;
Chest
primos
=
{
:
2
,
3
,
5
,
7
,
11
,
13
,
17
,
19
:
}
;
Chest
pares
=
{
:
2
,
4
,
6
,
8
,
10
:
}
;
Chest
vocales
=
{
:
'a'
,
'e'
,
'i'
,
'o'
,
'u'
:
}
;
Chest
consonantes
=
{
:
'b'
,
'c'
,
'd'
,
'f'
,
'g'
:
}
;
Chest
nombres
=
{
:
"Steve"
,
"Alex"
,
"Herobrine"
,
"Notch"
:
}
;
Chest
herramientas
=
{
:
"Espada"
,
"Pico"
,
"Hacha"
,
"Pala"
:
}
;
Chest
vacio
=
{
:
:
}
;
Chest
singleton
=
{
:
42
:
}
;
Chest
mezcla
=
{
:
1
,
'a'
,
"texto"
:
}
;
Chest
calculados
=
{
:
1
+
1
,
2
*
2
,
10
2
:
}
;
Chest
booleanos
=
{
:
On
,
Off
:
}
;
SpawnPoint
PolloCrudo
add
(
numeros
,
6
)
;
dropperSpider
(
"Después de add(numeros, 6):"
)
;
drop
(
primos
,
2
)
;
dropperSpider
(
"Después de drop(primos, 2):"
)
;
Chest
union
=
feed
(
numeros
,
primos
)
;
dropperSpider
(
"Unión de numeros y primos:"
)
;
Chest
interseccion
=
map
(
numeros
,
pares
)
;
dropperSpider
(
"Intersección de numeros y pares:"
)
;
Torch
contiene
=
biom
(
vocales
,
'a'
)
;
dropperTorch
(
contiene
)
;
Torch
esVacio
=
void
(
vacio
)
;
dropperTorch
(
esVacio
)
;
Chest
conEspacios
=
{
:
'a'
,
'b'
,
'c'
:
}
;
Chest
conComentarios
=
{
:
1
,
2
,
3
:
}
;
Chest
{
:
1
,
'x'
,
"y"
:
}
;
PolloAsado
worldSave
WorldName
PruebaLitArchivos
:
Inventory
Book
archivoConfiguracion
=
{
"config.txt"
,
'L'
}
;
Book
archivoJugadores
=
{
"jugadores.dat"
,
'L'
}
;
Book
archivoNiveles
=
{
"niveles/nivel1.map"
,
'L'
}
;
Book
archivoLog
=
{
"sistema.log"
,
'E'
}
;
Book
archivoResultados
=
{
"resultados.txt"
,
'E'
}
;
Book
archivoExportacion
=
{
"export/datos.csv"
,
'E'
}
;
Book
archivoPuntajes
=
{
"puntajes.dat"
,
'A'
}
;
Book
archivoInventario
=
{
"inventario.sav"
,
'A'
}
;
Book
archivoEspecial
=
{
"archivo con espacios.txt"
,
'L'
}
;
Book
archivoEspecial2
=
{
"datos_especiales-2023.dat"
,
'E'
}
;
Book
archivoRutaRelativa
=
{
"../datos/config.ini"
,
'L'
}
;
Book
archivoRutaAbsoluta
=
{
"C:/Notch/Engine/data.bin"
,
'E'
}
;
Book
archivoTexto
=
{
"readme.txt"
,
'L'
}
;
Book
archivoImagen
=
{
"textura.png"
,
'L'
}
;
Book
archivoJSON
=
{
"settings.json"
,
'A'
}
;
Book
archivoXML
=
{
"estructura.xml"
,
'A'
}
;
Book
conBarras
=
{
"dir/subdir/archivo.ext"
,
'L'
}
;
Book
conPuntos
=
{
"../../archivo.ext"
,
'E'
}
;
Book
espaciado1
=
{
"compacto.txt"
,
'L'
}
;
Book
espaciado2
=
{
"espacios.txt"
,
'E'
}
;
Book
comentado
=
{
"log.txt"
,
'L'
}
;
SpawnPoint
PolloCrudo
unlock
(
archivoLog
)
;
forge
(
archivoLog
,
"Entrada de log: Inicio de programa"
)
;
lock
(
archivoLog
)
;
Book
nuevoArchivo
=
make
(
{
"nuevo.txt"
,
'E'
}
)
;
unlock
(
archivoConfiguracion
)
;
Spider
contenido
=
gather
(
archivoConfiguracion
)
;
lock
(
archivoConfiguracion
)
;
expand
(
archivoLog
,
archivoResultados
)
;
Book
{
"sinVariable.txt"
,
'A'
}
;
Book
arch1
=
{
"uno.txt"
,
'L'
}
;
Book
arch2
=
{
"dos.txt"
,
'E'
}
;
Book
conComentarioMedio
=
{
"comentado.txt"
,
'A'
}
;
PolloAsado
worldSave
WorldName
PruebaOpAritmeticos
:
Inventory
Stack
a
=
10
;
Stack
b
=
3
;
Stack
c
;
Stack
resultado
;
SpawnPoint
PolloCrudo
c
=
a
+
b
;
dropperSpider
(
"Suma: "
bind
c
)
;
c
=
a
-
b
;
dropperSpider
(
"Resta: "
bind
c
)
;
c
=
a
*
b
;
dropperSpider
(
"Multiplicación: "
bind
c
)
;
c
=
a
b
;
dropperSpider
(
"División entera: "
bind
c
)
;
c
=
a
%
b
;
dropperSpider
(
"Módulo: "
bind
c
)
;
resultado
=
a
+
b
*
c
;
dropperSpider
(
"a + b * c = "
bind
resultado
)
;
resultado
=
(
a
+
b
)
*
c
;
dropperSpider
(
"(a + b) * c = "
bind
resultado
)
;
resultado
=
a
+
b
+
c
;
dropperSpider
(
"a + b + c = "
bind
resultado
)
;
resultado
=
a
*
b
c
+
a
-
b
;
dropperSpider
(
"a * b // c + a - b = "
bind
resultado
)
;
resultado
=
-
a
;
dropperSpider
(
"-a = "
bind
resultado
)
;
resultado
=
5
+
3
;
dropperSpider
(
"5 + 3 = "
bind
resultado
)
;
resultado
=
-
(
a
+
b
)
;
dropperSpider
(
"-(a + b) = "
bind
resultado
)
;
resultado
=
a
+
b
;
resultado
=
a
-
b
;
resultado
=
a
*
b
;
resultado
=
a
b
;
resultado
=
a
%
b
;
resultado
=
a
+
b
;
resultado
=
a
-
b
;
resultado
=
a
*
b
;
resultado
=
a
b
;
resultado
=
a
%
b
;
resultado
=
a
+
b
;
resultado
=
a
*
b
;
resultado
=
(
(
(
(
a
+
b
)
*
c
)
2
)
%
10
)
;
soulsand
a
;
resultado
=
a
+
b
;
magma
b
;
resultado
=
a
-
b
;
PolloAsado
worldSave
WorldName
PruebaOpFlotantes
:
Inventory
Ghast
x
=
10.5
;
Ghast
y
=
3.25
;
Ghast
z
;
Ghast
resultado
;
SpawnPoint
PolloCrudo
z
=
x
:
+
y
;
dropperSpider
(
"Suma flotante: "
bind
z
)
;
z
=
x
:
-
y
;
dropperSpider
(
"Resta flotante: "
bind
z
)
;
z
=
x
:
*
y
;
dropperSpider
(
"Multiplicación flotante: "
bind
z
)
;
z
=
x
:
y
;
dropperSpider
(
"División flotante: "
bind
z
)
;
z
=
x
:
%
y
;
dropperSpider
(
"Módulo flotante: "
bind
z
)
;
resultado
=
x
:
+
y
:
*
z
;
dropperSpider
(
"x :+ y :* z = "
bind
resultado
)
;
resultado
=
(
x
:
+
y
)
:
*
z
;
dropperSpider
(
"(x :+ y) :* z = "
bind
resultado
)
;
resultado
=
x
:
+
y
:
+
z
;
dropperSpider
(
"x :+ y :+ z = "
bind
resultado
)
;
resultado
=
x
:
*
y
:
z
:
+
x
:
-
y
;
dropperSpider
(
"x :* y :// z :+ x :- y = "
bind
resultado
)
;
resultado
=
-
x
;
dropperSpider
(
"-x = "
bind
resultado
)
;
resultado
=
5.5
:
+
3.2
;
dropperSpider
(
"5.5 :+ 3.2 = "
bind
resultado
)
;
resultado
=
-
(
x
:
+
y
)
;
dropperSpider
(
"-(x :+ y) = "
bind
resultado
)
;
resultado
=
x
:
+
y
;
resultado
=
x
:
-
y
;
resultado
=
x
:
*
y
;
resultado
=
x
:
y
;
resultado
=
x
:
%
y
;
resultado
=
x
:
+
y
;
resultado
=
x
:
-
y
;
resultado
=
x
:
*
y
;
resultado
=
x
:
y
;
resultado
=
x
:
%
y
;
resultado
=
x
:
+
y
;
resultado
=
x
:
*
y
;
resultado
=
(
(
(
(
x
:
+
y
)
:
*
z
)
:
2.0
)
:
%
10.0
)
;
Ghast
mezcla1
=
x
:
+
5
;
Ghast
mezcla2
=
3.5
:
*
y
;
Ghast
mezcla3
=
x
:
+
(
y
:
*
2.0
)
:
1.5
;
Spider
texto
=
"Notch:Engine"
;
Stack
entero
=
(
x
:
+
y
)
>
>
Stack
;
PolloAsado
worldSave
WorldName
PruebaOpComparacion
:
Inventory
Stack
a
=
10
;
Stack
b
=
5
;
Torch
resultado
;
Ghast
x
=
3.5
;
Ghast
y
=
2.75
;
Spider
cadena1
=
"abc"
;
Spider
cadena2
=
"def"
;
Rune
char1
=
'A'
;
Rune
char2
=
'B'
;
Torch
bool1
=
On
;
Torch
bool2
=
Off
;
SpawnPoint
PolloCrudo
resultado
=
a
<
b
;
dropperSpider
(
"a < b: "
bind
resultado
)
;
resultado
=
x
<
y
;
dropperSpider
(
"x < y: "
bind
resultado
)
;
resultado
=
cadena1
<
cadena2
;
dropperSpider
(
"cadena1 < cadena2: "
bind
resultado
)
;
resultado
=
char1
<
char2
;
dropperSpider
(
"char1 < char2: "
bind
resultado
)
;
resultado
=
a
>
b
;
dropperSpider
(
"a > b: "
bind
resultado
)
;
resultado
=
x
>
y
;
dropperSpider
(
"x > y: "
bind
resultado
)
;
resultado
=
a
<=
b
;
dropperSpider
(
"a <= b: "
bind
resultado
)
;
resultado
=
x
<=
y
;
dropperSpider
(
"x <= y: "
bind
resultado
)
;
resultado
=
a
>=
b
;
dropperSpider
(
"a >= b: "
bind
resultado
)
;
resultado
=
x
>=
y
;
dropperSpider
(
"x >= y: "
bind
resultado
)
;
resultado
=
a
is
b
;
dropperSpider
(
"a is b: "
bind
resultado
)
;
resultado
=
x
is
y
;
dropperSpider
(
"x is y: "
bind
resultado
)
;
resultado
=
cadena1
is
cadena2
;
dropperSpider
(
"cadena1 is cadena2: "
bind
resultado
)
;
resultado
=
bool1
is
bool2
;
dropperSpider
(
"bool1 is bool2: "
bind
resultado
)
;
resultado
=
a
isNot
b
;
dropperSpider
(
"a isNot b: "
bind
resultado
)
;
resultado
=
x
isNot
y
;
dropperSpider
(
"x isNot y: "
bind
resultado
)
;
resultado
=
cadena1
isNot
cadena2
;
dropperSpider
(
"cadena1 isNot cadena2: "
bind
resultado
)
;
resultado
=
bool1
isNot
bool2
;
dropperSpider
(
"bool1 isNot bool2: "
bind
resultado
)
;
resultado
=
a
<
b
;
resultado
=
a
>
b
;
resultado
=
a
<=
b
;
resultado
=
a
>=
b
;
resultado
=
aisb
;
resultado
=
a
is
b
;
resultado
=
aisNotb
;
resultado
=
a
isNot
b
;
resultado
=
a
<
b
;
resultado
=
a
>
b
;
resultado
=
a
<=
b
;
resultado
=
a
>=
b
;
resultado
=
a
is
b
;
resultado
=
a
isNot
b
;
target
a
<
b
craft
hit
PolloCrudo
dropperSpider
(
"a es menor que b"
)
;
PolloAsado
repeater
x
>
y
craft
PolloCrudo
dropperSpider
(
"x es mayor que y"
)
;
PolloAsado
resultado
=
(
a
+
b
)
>
(
x
:
+
y
)
;
resultado
=
a
*
2
<=
b
*
3
;
resultado
=
(
a
2
)
is
(
b
1
)
;
resultado
=
bind
(
cadena1
,
cadena2
)
isNot
"abcdef"
;
Spider
islandia
=
"país"
;
Stack
isNotacion
=
42
;
PolloAsado
worldSave
WorldName
PruebaOpAsignacion
:
Inventory
Stack
contador
=
10
;
Stack
acumulador
=
0
;
Ghast
decimal
=
5.5
;
Spider
texto
=
"Notch"
;
Shelf
[
5
]
Stack
arreglo
;
Entity
Punto
PolloCrudo
Stack
x
;
Stack
y
;
PolloAsado
;
Entity
Punto
punto
;
SpawnPoint
PolloCrudo
contador
=
5
;
dropperSpider
(
"Asignación simple: "
bind
contador
)
;
decimal
=
3.14
;
texto
=
"Engine"
;
contador
+
=
3
;
dropperSpider
(
"Asignación con suma: "
bind
contador
)
;
acumulador
=
0
;
acumulador
+
=
contador
;
acumulador
+
=
2
;
dropperSpider
(
"Acumulador después de += : "
bind
acumulador
)
;
contador
-
=
2
;
dropperSpider
(
"Asignación con resta: "
bind
contador
)
;
acumulador
=
20
;
acumulador
-
=
5
;
acumulador
-
=
contador
;
dropperSpider
(
"Acumulador después de -= : "
bind
acumulador
)
;
contador
*
=
3
;
dropperSpider
(
"Asignación con multiplicación: "
bind
contador
)
;
acumulador
=
2
;
acumulador
*
=
contador
;
dropperSpider
(
"Acumulador después de *= : "
bind
acumulador
)
;
contador
=
2
;
dropperSpider
(
"Asignación con división: "
bind
contador
)
;
acumulador
=
50
;
acumulador
=
5
;
dropperSpider
(
"Acumulador después de /= : "
bind
acumulador
)
;
contador
%
=
3
;
dropperSpider
(
"Asignación con módulo: "
bind
contador
)
;
acumulador
=
17
;
acumulador
%
=
5
;
dropperSpider
(
"Acumulador después de %= : "
bind
acumulador
)
;
arreglo
[
0
]
=
10
;
arreglo
[
1
]
=
20
;
arreglo
[
2
]
=
30
;
arreglo
[
0
]
+
=
5
;
dropperSpider
(
"arreglo[0] después de += : "
bind
arreglo
[
0
]
)
;
arreglo
[
1
]
-
=
5
;
dropperSpider
(
"arreglo[1] después de -= : "
bind
arreglo
[
1
]
)
;
arreglo
[
2
]
*
=
2
;
dropperSpider
(
"arreglo[2] después de *= : "
bind
arreglo
[
2
]
)
;
punto
@
x
=
10
;
punto
@
y
=
20
;
punto
@
x
+
=
5
;
dropperSpider
(
"punto@x después de += : "
bind
punto
@
x
)
;
punto
@
y
-
=
8
;
dropperSpider
(
"punto@y después de -= : "
bind
punto
@
y
)
;
contador
=
5
;
contador
+
=
3
;
contador
-
=
2
;
contador
*
=
4
;
contador
=
2
;
contador
%
=
3
;
contador
=
5
;
contador
+
=
3
;
contador
-
=
2
;
contador
*
=
4
;
contador
=
2
;
contador
%
=
3
;
contador
=
10
;
contador
+
=
5
;
Stack
a
=
1
,
b
=
2
,
c
=
3
;
contador
=
(
a
+
b
)
*
c
;
contador
+
=
a
*
b
;
contador
-
=
a
+
b
;
contador
*
=
(
a
*
2
)
+
(
b
*
3
)
;
contador
=
a
+
1
;
contador
%
=
b
*
2
;
a
=
10
;
b
=
20
;
c
=
30
;
Spider
igual_texto
=
"Este texto tiene un signo = dentro"
;
Spider
mas_texto
=
"Este texto tiene un signo + dentro"
;
Spider
menos_texto
=
"Este texto tiene un signo - dentro"
;
Spider
por_texto
=
"Este texto tiene un signo * dentro"
;
Spider
div_texto
=
"Este texto tiene un signo / dentro"
;
Spider
mod_texto
=
"Este texto tiene un signo % dentro"
;
PolloAsado
worldSave
WorldName
PruebaOpAcceso
:
Inventory
Shelf
[
5
]
Stack
numeros
;
Shelf
[
3
]
Shelf
[
3
]
matriz
;
Shelf
[
2
]
Shelf
[
2
]
Shelf
[
2
]
cubo
;
Spider
texto
=
"Notch Engine"
;
Entity
Punto
PolloCrudo
Stack
x
;
Stack
y
;
Stack
z
;
PolloAsado
;
Entity
Punto
punto
;
Entity
Persona
PolloCrudo
Spider
nombre
;
Stack
edad
;
Torch
activo
;
Shelf
[
3
]
Stack
notas
;
PolloAsado
;
Entity
Persona
estudiante
;
Shelf
[
3
]
Entity
Punto
puntos
;
Entity
Contenedor
PolloCrudo
Shelf
[
5
]
Stack
valores
;
Spider
etiqueta
;
PolloAsado
;
Entity
Contenedor
caja
;
SpawnPoint
PolloCrudo
numeros
[
0
]
=
10
;
numeros
[
1
]
=
20
;
numeros
[
2
]
=
30
;
Stack
valor
=
numeros
[
0
]
;
dropperSpider
(
"Valor en numeros[0]: "
bind
valor
)
;
Stack
indice
=
2
;
valor
=
numeros
[
indice
]
;
dropperSpider
(
"Valor en numeros[indice]: "
bind
valor
)
;
valor
=
numeros
[
1
+
1
]
;
dropperSpider
(
"Valor en numeros[1 + 1]: "
bind
valor
)
;
matriz
[
0
]
[
0
]
=
11
;
matriz
[
0
]
[
1
]
=
12
;
matriz
[
1
]
[
0
]
=
21
;
matriz
[
1
]
[
1
]
=
22
;
valor
=
matriz
[
1
]
[
1
]
;
dropperSpider
(
"Valor en matriz[1][1]: "
bind
valor
)
;
valor
=
matriz
[
indice
-
1
]
[
indice
-
1
]
;
dropperSpider
(
"Valor en matriz[indice - 1][indice - 1]: "
bind
valor
)
;
cubo
[
0
]
[
0
]
[
0
]
=
111
;
cubo
[
1
]
[
1
]
[
1
]
=
222
;
valor
=
cubo
[
1
]
[
1
]
[
1
]
;
dropperSpider
(
"Valor en cubo[1][1][1]: "
bind
valor
)
;
Rune
caracter
=
texto
[
0
]
;
dropperSpider
(
"Carácter en texto[0]: "
bind
caracter
)
;
caracter
=
texto
[
6
]
;
dropperSpider
(
"Carácter en texto[6]: "
bind
caracter
)
;
caracter
=
texto
[
indice
*
2
]
;
dropperSpider
(
"Carácter en texto[indice * 2]: "
bind
caracter
)
;
texto
[
0
]
=
'n'
;
dropperSpider
(
"Texto modificado: "
bind
texto
)
;
punto
@
x
=
10
;
punto
@
y
=
20
;
punto
@
z
=
30
;
valor
=
punto
@
x
;
dropperSpider
(
"Valor en punto@x: "
bind
valor
)
;
punto
@
y
=
punto
@
x
*
2
;
dropperSpider
(
"Valor en punto@y después de asignación: "
bind
punto
@
y
)
;
estudiante
@
nombre
=
"Steve"
;
estudiante
@
edad
=
25
;
estudiante
@
activo
=
On
;
estudiante
@
notas
[
0
]
=
85
;
estudiante
@
notas
[
1
]
=
90
;
estudiante
@
notas
[
2
]
=
95
;
Spider
nombre
=
estudiante
@
nombre
;
dropperSpider
(
"Nombre del estudiante: "
bind
nombre
)
;
Stack
nota
=
estudiante
@
notas
[
1
]
;
dropperSpider
(
"Segunda nota del estudiante: "
bind
nota
)
;
puntos
[
0
]
@
x
=
1
;
puntos
[
0
]
@
y
=
2
;
puntos
[
0
]
@
z
=
3
;
puntos
[
1
]
@
x
=
4
;
puntos
[
1
]
@
y
=
5
;
puntos
[
1
]
@
z
=
6
;
valor
=
puntos
[
1
]
@
y
;
dropperSpider
(
"Valor en puntos[1]@y: "
bind
valor
)
;
caja
@
etiqueta
=
"Items"
;
caja
@
valores
[
0
]
=
100
;
caja
@
valores
[
1
]
=
200
;
valor
=
caja
@
valores
[
1
]
;
dropperSpider
(
"Valor en caja@valores[1]: "
bind
valor
)
;
valor
=
numeros
[
0
]
;
nombre
=
estudiante
@
nombre
;
valor
=
numeros
[
0
]
;
valor
=
matriz
[
1
]
[
1
]
;
nombre
=
estudiante
@
nombre
;
valor
=
cubo
[
0
]
[
matriz
[
0
]
[
0
]
%
3
]
[
numeros
[
0
]
10
]
;
valor
=
numeros
[
0
]
;
nombre
=
estudiante
@
nombre
;
Spider
textoCuadrado
=
"Esto no es un [acceso]"
;
Spider
textoArroba
=
"Email: usuario@dominio.com"
;
PolloAsado
worldSave
WorldName
PruebaOpEspeciales
:
Bedrock
Obsidian
Stack
MAX_SIZE
1024
;
Inventory
Stack
entero
=
42
;
Ghast
flotante
=
3.14159
;
Spider
texto
=
"Notch Engine"
;
Rune
caracter
=
'A'
;
Torch
booleano
=
On
;
Shelf
[
5
]
Stack
arreglo
;
Chest
conjunto
=
{
:
1
,
2
,
3
:
}
;
Entity
Punto
PolloCrudo
Stack
x
;
Stack
y
;
PolloAsado
;
Entity
Punto
punto
;
SpawnPoint
PolloCrudo
Stack
tamanoStack
=
chunk
Stack
;
Stack
tamanoGhast
=
chunk
Ghast
;
Stack
tamanoSpider
=
chunk
Spider
;
Stack
tamanoRune
=
chunk
Rune
;
Stack
tamanoTorch
=
chunk
Torch
;
dropperSpider
(
"Tamaño de Stack en bytes: "
bind
tamanoStack
)
;
dropperSpider
(
"Tamaño de Ghast en bytes: "
bind
tamanoGhast
)
;
dropperSpider
(
"Tamaño de Spider en bytes: "
bind
tamanoSpider
)
;
dropperSpider
(
"Tamaño de Rune en bytes: "
bind
tamanoRune
)
;
dropperSpider
(
"Tamaño de Torch en bytes: "
bind
tamanoTorch
)
;
Stack
tamanoShelf
=
chunk
Shelf
[
5
]
Stack
;
Stack
tamanoChest
=
chunk
Chest
;
Stack
tamanoPunto
=
chunk
Punto
;
dropperSpider
(
"Tamaño de arreglo en bytes: "
bind
tamanoShelf
)
;
dropperSpider
(
"Tamaño de conjunto en bytes: "
bind
tamanoChest
)
;
dropperSpider
(
"Tamaño de Punto en bytes: "
bind
tamanoPunto
)
;
Stack
tamanoVariable
=
chunk
entero
;
Stack
tamanoArreglo
=
chunk
arreglo
;
Stack
tamanoTexto
=
chunk
texto
;
dropperSpider
(
"Tamaño de variable entero en bytes: "
bind
tamanoVariable
)
;
dropperSpider
(
"Tamaño de variable arreglo en bytes: "
bind
tamanoArreglo
)
;
dropperSpider
(
"Tamaño de variable texto en bytes: "
bind
tamanoTexto
)
;
Stack
tamanoExpresion
=
chunk
(
entero
*
2
+
10
)
;
dropperSpider
(
"Tamaño de expresión en bytes: "
bind
tamanoExpresion
)
;
Stack
enteroDeFlotante
=
flotante
>
>
Stack
;
dropperSpider
(
"Flotante convertido a entero: "
bind
enteroDeFlotante
)
;
Torch
booleanoDeEntero
=
entero
>
>
Torch
;
dropperSpider
(
"Entero convertido a booleano: "
bind
booleanoDeEntero
)
;
Rune
caracterDeTexto
=
texto
>
>
Rune
;
dropperSpider
(
"Primer carácter del texto: "
bind
caracterDeTexto
)
;
Stack
resultadoEntero
=
(
flotante
:
+
2.5
)
>
>
Stack
;
dropperSpider
(
"Suma flotante convertida a entero: "
bind
resultadoEntero
)
;
Stack
tam1
=
chunkStack
;
Stack
tam2
=
chunk
Stack
;
Stack
tam3
=
chunk
(
Stack
)
;
Stack
ent1
=
flotante
>
>
Stack
;
Stack
ent2
=
flotante
>
>
Stack
;
Stack
tam4
=
chunk
Stack
;
Stack
ent3
=
flotante
>
>
Stack
;
Stack
tam5
=
chunk
Stack
;
Stack
ent4
=
flotante
>
>
Stack
;
Stack
tamCombinado
=
chunk
(
flotante
>
>
Stack
)
;
Spider
textoMayor
=
"Esto no es una coherción >>"
;
Spider
textoChunk
=
"La palabra chunk no es un operador aquí"
;
Stack
resultado
=
(
flotante
:
*
2.0
>
>
Stack
)
+
(
entero
*
3
)
;
target
(
flotante
>
>
Stack
)
>
3
craft
hit
PolloCrudo
dropperSpider
(
"La parte entera de flotante es mayor que 3"
)
;
PolloAsado
PolloAsado
worldSave
WorldName
PruebaComLinea
:
Bedrock
Obsidian
Stack
MAX_LEVEL
100
;
Obsidian
Spider
VERSION
"1.0"
;
Inventory
Stack
contador
=
0
;
Spider
texto
=
"Notch Engine"
;
Rune
inicial
;
Stack
a
=
10
,
b
=
20
;
Recipe
Spell
calcular
(
Stack
::
a
,
b
)
->
Stack
;
CraftingTable
Spell
calcular
(
Stack
::
a
,
b
)
->
Stack
PolloCrudo
Stack
resultado
=
a
+
b
;
respawn
resultado
;
PolloAsado
Ritual
mostrarMensaje
(
Spider
::
mensaje
)
PolloCrudo
dropperSpider
(
mensaje
)
;
PolloAsado
SpawnPoint
PolloCrudo
contador
=
5
;
target
contador
>
0
craft
hit
PolloCrudo
dropperSpider
(
"Contador positivo"
)
;
PolloAsado
Stack
resultado
=
contador
+
10
;
Stack
suma
=
calcular
(
5
,
10
)
;
;
PolloAsado
worldSave
WorldName
PruebaComBloque
:
Bedrock
Obsidian
Stack
MAX_LEVEL
100
;
Obsidian
Spider
VERSION
"1.0"
;
Inventory
Stack
contador
=
0
;
Spider
texto
=
"Notch Engine"
;
Rune
inicial
;
Stack
a
=
10
,
b
=
20
;
Recipe
Spell
calcular
(
Stack
::
a
,
b
)
->
Stack
;
CraftingTable
Spell
calcular
(
Stack
::
a
,
b
)
->
Stack
PolloCrudo
Stack
resultado
=
a
+
b
;
respawn
resultado
;
PolloAsado
Ritual
mostrarMensaje
(
Spider
::
mensaje
)
PolloCrudo
dropperSpider
(
mensaje
)
;
PolloAsado
SpawnPoint
PolloCrudo
contador
=
5
+
10
;
target
contador
>
0
craft
hit
PolloCrudo
dropperSpider
(
"Contador positivo"
)
;
PolloAsado
dentro
pero
sin
cerrar
aún
*
secuencias
*
PolloAsado
worldSave
WorldName
PruebaComentarios
:
Inventory
Stack
contador
=
10
;
Spider
texto
=
"Comentario /* falso */ dentro de un string"
;
Rune
caracter
=
'*'
;
SpawnPoint
PolloCrudo
dropperSpider
(
"Los comentarios son importantes"
)
;
PolloAsado
worldSave
WorldName
PruebaIdentificadoresSimples
:
Bedrock
Obsidian
Stack
MAX
100
;
Obsidian
Spider
TITULO
"Notch Engine"
;
Inventory
Stack
a
;
Stack
contador
;
Stack
nivel
;
Stack
x
;
Stack
y
;
Stack
z
;
Stack
posicion
;
Stack
altura
;
Stack
ancho
;
Spider
nombre
;
Spider
texto
;
Spider
mensaje
;
Spider
saludo
;
Torch
activo
;
Torch
visible
;
Torch
terminado
;
Rune
inicial
;
Rune
caracter
;
Rune
simbolo
;
Ghast
pi
;
Ghast
temperatura
;
Ghast
velocidad
;
Stack
Contador
;
Spider
Nombre
;
Torch
Activo
;
Stack
i
;
Stack
j
;
Stack
k
;
Rune
c
;
Spider
s
;
Torch
b
;
Ghast
f
;
CraftingTable
Spell
suma
(
Stack
::
a
,
b
)
->
Stack
PolloCrudo
Stack
resultado
;
resultado
=
a
+
b
;
respawn
resultado
;
PolloAsado
Ritual
imprimir
(
Spider
::
mensaje
)
PolloCrudo
dropperSpider
(
mensaje
)
;
PolloAsado
SpawnPoint
PolloCrudo
Stack
valor
;
Stack
resultado
;
Spider
mensaje
;
valor
=
10
;
mensaje
=
"Hola"
;
resultado
=
valor
+
5
;
valor
=
suma
(
valor
,
20
)
;
ender_pearl
imprimir
(
mensaje
)
;
PolloAsado
worldSave
WorldName
PruebaIdentificadoresComplejos
:
Bedrock
Obsidian
Stack
MAX_LEVEL
100
;
Obsidian
Stack
MIN_LEVEL
1
;
Obsidian
Spider
GAME_TITLE
"Notch Engine"
;
Obsidian
Spider
VERSION_1_0
"v1.0"
;
Inventory
Stack
player_level
;
Stack
enemy_count
;
Stack
max_health
;
Stack
min_damage
;
Stack
current_position_x
;
Stack
counter1
;
Stack
item2
;
Stack
level3d
;
Stack
position2d
;
Stack
player1_health
;
Stack
item_1
;
Stack
player_2_score
;
Stack
enemy_level_3
;
Stack
position_x_1
;
Stack
inventory_slot_5
;
Stack
_temp
;
Stack
_internal_counter
;
Stack
_system_value
;
Stack
_player_data
;
Stack
very_long_variable_name_with_many_words
;
Spider
extremely_long_message_text_that_describes_something_in_detail
;
Torch
is_player_currently_in_creative_mode_with_flight_enabled
;
Stack
player5_current_health_max_100
;
Stack
enemy_3d_position_coordinate_x_12
;
Rune
player_initial_1
;
Spider
user_5_name
;
CraftingTable
Spell
calculate_total_damage
(
Stack
::
base_damage
,
critical_multiplier
;
Torch
::
is_headshot
)
->
Stack
PolloCrudo
Stack
total_damage
;
total_damage
=
base_damage
*
critical_multiplier
;
target
is_headshot
craft
hit
PolloCrudo
total_damage
=
total_damage
*
2
;
PolloAsado
respawn
total_damage
;
PolloAsado
Ritual
display_player_stats
(
Spider
::
player_name
;
Stack
level_1
,
health_points_100
)
PolloCrudo
dropperSpider
(
"Player: "
bind
player_name
)
;
dropperSpider
(
"Level: "
bind
level_1
)
;
dropperSpider
(
"Health: "
bind
health_points_100
)
;
PolloAsado
SpawnPoint
PolloCrudo
Stack
player1_health
=
100
;
Stack
enemy_count_5
=
10
;
Spider
main_player_name
=
"Steve_123"
;
player1_health
=
player1_health
-
20
;
enemy_count_5
=
calculate_total_damage
(
10
,
2
,
On
)
;
ender_pearl
display_player_stats
(
main_player_name
,
5
,
player1_health
)
;
Stack
___special_value
=
42
;
dropperStack
(
___special_value
)
;
PolloAsado
worldSave
WorldName
PruebaIdentificadoresSimilares
:
Bedrock
Obsidian
Stack
WorldNameTest
100
;
Obsidian
Spider
BedrockType
"Hard Stone"
;
Obsidian
Torch
InventoryFull
On
;
Inventory
Stack
worldname
;
Stack
WorldName2
;
Stack
bedrock
;
Stack
Bedrock_Type
;
Stack
inventory
;
Stack
InventorySlot
;
Stack
recipe
;
Stack
RecipeBook
;
Stack
craftingtable
;
Stack
CraftingTable2
;
Stack
spawnpoint
;
Stack
SpawnPoint_Main
;
Stack
stack
;
Spider
spider
;
Torch
torch
;
Rune
rune
;
Ghast
ghast
;
Chest
chest
;
Book
book
;
Stack
pollocrudo
;
Stack
PolloAsado
;
Stack
polloAsadoExtra
;
Stack
repeater
;
Stack
target
;
Stack
hit
;
Stack
miss
;
Stack
craft
;
Stack
jukebox
;
Stack
disc
;
Stack
silence
;
Stack
spawner
;
Stack
exhausted
;
Stack
walk
;
Stack
set
;
Stack
to
;
Stack
step
;
Stack
wither
;
Stack
creeper
;
Stack
enderPearl
;
Stack
enderpearlitem
;
Stack
ragequit
;
Stack
spell
;
Stack
Spell_Cast
;
Stack
ritual
;
Stack
RitualCeremony
;
Stack
respawn
;
Stack
respawnPoint
;
Stack
ender_pearl
;
Stack
enderpearlTeleport
;
Stack
soulsand
;
Stack
SoulSandBlock
;
Stack
magma
;
Stack
MagmaBlock
;
Stack
and
;
Stack
andOperator
;
Stack
or
;
Stack
orGate
;
Stack
not
;
Stack
notOperator
;
Stack
xor
;
Stack
xorCalculation
;
Stack
is
;
Stack
isNot
;
Stack
isEqual
;
Torch
on
;
Torch
onSwitch
;
Torch
off
;
Torch
offState
;
Stack
hopper
;
Stack
hopperMinecart
;
Stack
dropper
;
Stack
dropperFunction
;
CraftingTable
Spell
worldNameGenerator
(
)
->
Spider
PolloCrudo
Spider
spawnpoint
=
"DefaultSpawn"
;
Stack
craft
=
10
;
Spider
ritual
=
"Magic"
;
respawn
"Generated"
;
PolloAsado
Ritual
craftingTableMaker
(
Spider
::
recipe
;
Stack
inventory
)
PolloCrudo
Stack
spell
=
20
;
Stack
worldname
=
30
;
Torch
on
=
Off
;
dropperSpider
(
"Crafting table ready"
)
;
PolloAsado
SpawnPoint
PolloCrudo
Stack
worldname
=
1
;
Stack
bedrock
=
2
;
Stack
inventory
=
3
;
Stack
recipe
=
4
;
Stack
craftingtable
=
5
;
Stack
spawnpoint
=
6
;
worldname
=
worldname
+
bedrock
;
inventory
=
craftingtable
*
spawnpoint
;
target
worldname
>
recipe
craft
hit
PolloCrudo
Spider
spell
=
"Magic"
;
dropperSpider
(
spell
)
;
PolloAsado
Spider
generatedName
=
worldNameGenerator
(
)
;
ender_pearl
craftingTableMaker
(
"New Recipe"
,
inventory
)
;
PolloAsado
worldSave
WorldName
PruebaStringsLargos
:
Inventory
Spider
string_normal
=
"Este es un string normal"
;
Spider
string_largo
=
"Este es un string extremadamente largo para probar cómo maneja el analizador léxico los tokens de gran tamaño. El propósito es verificar si el buffer del analizador puede manejar correctamente cadenas que exceden el tamaño típico. En Minecraft, los jugadores pueden construir estructuras enormes y elaboradas, similar a cómo este string se extiende más allá de los límites normales. Las cadenas largas son útiles para almacenar textos extensos como descripciones, historias, o mensajes de diálogo en juegos. Este string sigue creciendo para asegurar que supere los límites habituales de procesamiento del analizador léxico."
;
Spider
string_muy_largo
=
"Este string es aún más largo que el anterior, llegando a aproximadamente mil caracteres para poner realmente a prueba los límites del analizador léxico. En el desarrollo de compiladores, es importante verificar cómo responde el sistema ante casos extremos. Los buffers mal dimensionados podrían causar desbordamientos o truncamientos inesperados. En el mundo de Minecraft, esto sería comparable a construir una megaestructura que se extiende hasta los límites permitidos del mundo. Es crucial que el compilador maneje correctamente estos casos límite, ya que en aplicaciones reales, los usuarios pueden introducir textos extremadamente largos, como documentación, logs detallados, o incluso código generado automáticamente. Este string continúa creciendo, añadiendo más y más caracteres para asegurar que pruebe adecuadamente la capacidad del buffer del analizador léxico. Una implementación robusta debería ser capaz de manejar este token sin problemas, reconociéndolo correctamente como un único string literal, sin importar su longitud. El tamaño máximo debería estar limitado únicamente por la memoria disponible en el sistema, no por limitaciones arbitrarias en el diseño del analizador léxico. Este string sigue y sigue, añadiendo más palabras y caracteres, para garantizar que realmente ponga a prueba los límites del analizador."
;
Spider
string_con_escapes
=
"Este string incluye secuencias de escape como: \n nueva línea, \t tabulación, \" comillas dobles, \\ barra invertida, y otros caracteres especiales como !@#$%^&*()_+-={}[]|:;<>,.?/~`"
;
Spider
string_multilinea
=
"Línea 1\nLínea 2\nLínea 3\nLínea 4\nLínea 5\nLínea 6\nLínea 7\nLínea 8\nLínea 9\nLínea 10\nLínea 11\nLínea 12\nLínea 13\nLínea 14\nLínea 15\nLínea 16\nLínea 17\nLínea 18\nLínea 19\nLínea 20"
;
Spider
string_simbolos
=
"Este string contiene símbolos que son tokens en Notch Engine: +, -, *, //, %, :+, :-, :*, :%, ://, @, [], {}, {: :}, {/ /}, >>. También incluye palabras reservadas como WorldName, Inventory, SpawnPoint, craft, respawn, soulsand, magma, etc."
;
Spider
string_extremo
=
"Este string es extremadamente largo AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA, superando los dos mil caracteres para realmente llevar al límite la capacidad del analizador léxico. En el desarrollo de compiladores e intérpretes, es fundamental probar cómo maneja el sistema casos extremos como este. Cualquier limitación no prevista en el diseño podría manifestarse al procesar tokens de este tamaño. En Minecraft, esto sería equivalente a construir una estructura colosal que se extiende por miles de bloques en todas direcciones, poniendo a prueba los límites del motor del juego. Los analizadores léxicos deben estar preparados para manejar tokens de cualquier longitud razonable, ya que en aplicaciones del mundo real, los usuarios pueden necesitar procesar textos extremadamente largos. Ejemplos incluyen el procesamiento de documentos completos, archivos de configuración extensos, o incluso código generado automáticamente que puede extenderse por miles de líneas. Este string sigue creciendo, añadiendo más y más palabras y caracteres, para asegurar que realmente ponga a prueba los límites del buffer del analizador. Una implementación robusta debería manejar este token sin problemas, reconociéndolo correctamente como un único string literal completo, sin importar su tamaño. El tamaño máximo debería estar limitado únicamente por la memoria disponible en el sistema, no por limitaciones arbitrarias en el diseño del analizador. Este string continúa expandiéndose, añadiendo más contenido para garantizar que supere cualquier buffer de tamaño fijo que pueda haber sido implementado. Es importante también verificar que el rendimiento del analizador no se degrade exponencialmente con tokens muy grandes, lo que podría indicar algoritmos ineficientes. En el contexto de Notch Engine, inspirado en Minecraft, este string sería como un libro dentro del juego con una historia increíblemente detallada que se extiende por múltiples páginas. El analizador léxico debe procesar este token de manera eficiente, reconociéndolo como un único string literal y no fragmentándolo incorrectamente en múltiples tokens. Este string sigue creciendo, agregando más y más caracteres, para asegurar que realmente ponga a prueba los límites del analizador léxico. Continúa expandiéndose, como un mundo de Minecraft que se genera infinitamente, añadiendo más palabras y frases para llegar a una longitud verdaderamente extrema. Este string sigue y sigue y sigue, desafiando las capacidades del analizador, probando su robustez y eficiencia al manejar casos extremos como este."
;
SpawnPoint
PolloCrudo
dropperSpider
(
"Prueba de strings largos completada"
)
;
Stack
longitud
=
#
(
string_largo
)
;
dropperStack
(
longitud
)
;
Spider
subcadena
=
from
string_largo
#
#
0
#
#
50
;
dropperSpider
(
subcadena
)
;
PolloAsado
worldSave
WorldName
PruebaNumeroGrande
:
Bedrock
Obsidian
Stack
NUM_PEQUENO
42
;
Obsidian
Stack
NUM_MEDIANO
12345
;
Obsidian
Stack
NUM_GRANDE
9876543210
;
Obsidian
Stack
NUM_MUY_GRANDE
1234567890123456789
;
Obsidian
Stack
NEG_PEQUENO
-
42
;
Obsidian
Stack
NEG_MEDIANO
-
12345
;
Obsidian
Stack
NEG_GRANDE
-
9876543210
;
Obsidian
Stack
NEG_MUY_GRANDE
-
1234567890123456789
;
Obsidian
Stack
INT_16BIT_MAX
32767
;
Obsidian
Stack
INT_16BIT_MIN
-
32768
;
Obsidian
Stack
INT_32BIT_MAX
2147483647
;
Obsidian
Stack
INT_32BIT_MIN
-
2147483648
;
Obsidian
Stack
INT_64BIT_MAX
9223372036854775807
;
Obsidian
Stack
INT_64BIT_MIN
-
9223372036854775808
;
Obsidian
Stack
NUM_EXTREMO
123456789012345678901234567890
;
Obsidian
Stack
NEG_EXTREMO
-
123456789012345678901234567890
;
Inventory
Stack
num1
=
1234567890
;
Stack
num2
=
9876543210
;
Stack
grande1
=
123456789012345678
;
Stack
grande2
=
987654321098765432
;
Stack
max16
=
32767
;
Stack
min16
=
-
32768
;
Stack
max32
=
2147483647
;
Stack
min32
=
-
2147483648
;
Stack
max64
=
9223372036854775807
;
Stack
min64
=
-
9223372036854775808
;
Stack
extremo
=
123456789012345678901234567890
;
Shelf
[
2147483647
]
Stack
arregloGrande
;
Stack
suma
;
Stack
resta
;
Stack
multiplicacion
;
Stack
division
;
Stack
modulo
;
SpawnPoint
PolloCrudo
suma
=
num1
+
num2
;
resta
=
num2
-
num1
;
multiplicacion
=
num1
*
10
;
division
=
num2
10
;
modulo
=
num2
%
10
;
Stack
resultado1
=
grande1
+
grande2
;
Stack
resultado2
=
extremo
1000
;
Stack
posible_overflow
=
max32
+
1
;
Stack
posible_underflow
=
min32
-
1
;
Stack
producto_grande
=
grande1
*
grande2
;
Stack
division_extrema
=
extremo
3
;
dropperStack
(
suma
)
;
dropperStack
(
resta
)
;
dropperStack
(
multiplicacion
)
;
dropperStack
(
division
)
;
target
producto_grande
>
0
craft
hit
PolloCrudo
dropperSpider
(
"El resultado es positivo"
)
;
PolloAsado
Stack
i
=
0
;
repeater
i
<
5
craft
PolloCrudo
dropperStack
(
i
)
;
dropperStack
(
grande1
)
;
soulsand
i
;
PolloAsado
PolloAsado
worldSave
WorldName
PruebaPrecisionFlotante
:
Bedrock
Obsidian
Ghast
PI_SIMPLE
3.14
;
Obsidian
Ghast
PI_PRECISO
3.14159265358979323846
;
Obsidian
Ghast
EULER
2.71828182845904523536
;
Obsidian
Ghast
RAIZ_DOS
1.41421356237309504880
;
Obsidian
Ghast
PHI
1.61803398874989484820
;
Obsidian
Ghast
SPEED_OF_LIGHT
2.99792458
e8
;
Obsidian
Ghast
PLANCK_CONSTANT
6.62607015
e
-
34
;
Obsidian
Ghast
AVOGADRO
6.02214076
e23
;
Obsidian
Ghast
EXTREMO_PEQUENO
0.0000000000000000000000001
;
Obsidian
Ghast
EXTREMO_GRANDE
123456789012345678901234.5678901234567890
;
Obsidian
Ghast
NEG_PI
-
3.14159265358979
;
Obsidian
Ghast
NEG_EXTREMO
-
0.0000000000000000000000001
;
Obsidian
Ghast
CERO_DECIMAL
0.0
;
Obsidian
Ghast
SOLO_ENTERO
42.0
;
Obsidian
Ghast
SOLO_DECIMAL
0.42
;
Obsidian
Ghast
PUNTO_INICIAL
.
5
;
Inventory
Ghast
normal
=
3.14
;
Ghast
preciso
=
3.141592653589793
;
Ghast
pequeno
=
0.000000000123
;
Ghast
grande
=
1234567890.123456789
;
Ghast
punto_inicial
=
.
25
;
Ghast
sin_decimal
=
42
.
;
Ghast
cientifico1
=
1.23
e5
;
Ghast
cientifico2
=
4.56
e
-
7
;
Ghast
cientifico3
=
7.89
e
+
12
;
Ghast
muy_pequeno
=
0.000000000000000000000000000000000001
;
Ghast
muy_grande
=
999999999999999999999999999999999999999.9
;
Ghast
muchos_digitos
=
123456789012345.678901234567890
;
Ghast
neg_normal
=
-
3.14
;
Ghast
neg_preciso
=
-
3.141592653589793
;
Ghast
neg_pequeno
=
-
0.000000000123
;
Ghast
neg_cientifico
=
-
2.998
e8
;
Ghast
resultado1
;
Ghast
resultado2
;
Ghast
resultado3
;
SpawnPoint
PolloCrudo
resultado1
=
normal
:
+
preciso
;
resultado2
=
preciso
:
-
normal
;
resultado3
=
normal
:
*
2.0
;
Ghast
res_extremo1
=
muy_pequeno
:
*
1000000.0
;
Ghast
res_extremo2
=
muy_grande
:
1000000.0
;
Ghast
division1
=
1.0
:
3.0
;
Ghast
division2
=
2.0
:
3.0
;
Ghast
division_extrema
=
1.0
:
9999999999.0
;
Ghast
res_cientifico
=
cientifico1
:
*
cientifico2
;
dropperGhast
(
resultado1
)
;
dropperGhast
(
resultado2
)
;
dropperGhast
(
division1
)
;
dropperGhast
(
division2
)
;
target
division1
:
<
0.34
craft
hit
PolloCrudo
dropperSpider
(
"La división 1/3 es menor que 0.34"
)
;
PolloAsado
Ghast
i
=
0.0
;
repeater
i
:
<
1.0
craft
PolloCrudo
dropperGhast
(
i
)
;
i
=
i
:
+
0.2
;
PolloAsado
PolloAsado
worldSave
WorldName
PruebaComentarioLargo
:
Inventory
Stack
contador
=
0
;
Stack
despues_comentario
=
1
;
Spider
mensaje
=
"Prueba de comentarios largos"
;
SpawnPoint
PolloCrudo
Stack
i
=
0
;
repeater
i
<
5
craft
PolloCrudo
soulsand
i
;
dropperSpider
(
mensaje
bind
" - iteración "
bind
i
)
;
PolloAsado
dropperSpider
(
"Prueba de comentarios largos completada"
)
;
PolloAsado
worldSave
WorldName
PruebaTokensConsecutivos
:
Bedrock
Obsidian
Stack
MAX_LEVEL5
100
;
Obsidian
Stack
LEVEL_PLUS_SKILL
200
;
Obsidian
Stack
OFFSET_MINUS_5
50
;
Inventory
Stack
a
=
5
;
Stack
b
=
10
;
Stack
c
=
a
+
b
;
Stack
suma
=
5
+
3
;
Stack
resta
=
10
-
7
;
Stack
multiplicacion
=
4
*
3
;
Stack
division
=
20
4
;
Stack
modulo
=
7
%
2
;
Torch
comparacion1
=
5
<
10
;
Torch
comparacion2
=
5
>
3
;
Torch
comparacion3
=
5
<=
5
;
Torch
comparacion4
=
5
>=
5
;
Torch
comparacion5
=
5
is5
;
Torch
comparacion6
=
5
isNot6
;
Stack
expr1
=
5
+
3
*
2
;
Stack
expr2
=
(
5
+
3
)
*
2
;
Stack
expr3
=
5
+
(
3
*
2
)
;
Ghast
f1
=
3.14
;
Ghast
f2
=
f1
:
+
2.5
;
Ghast
f3
=
f1
:
-
1.5
;
Ghast
f4
=
f1
:
*
2.0
;
Ghast
f5
=
f1
:
1.5
;
Shelf
[
5
]
Stack
arreglo
;
Entity
Jugador
PolloCrudo
Spider
nombre
;
Stack
nivel
;
PolloAsado
;
Spider
texto
=
"Hola"
;
Rune
caracter
=
'A'
;
Torch
booleano
=
On
;
Stack
arr
[
0
]
=
10
;
Stack
x
=
1
,
y
=
2
,
z
=
3
;
Stack
normal1
=
10
;
Stack
normal2
=
20
;
Spider
mensaje
=
"Tokens consecutivos"
;
SpawnPoint
PolloCrudo
suma
=
normal1
+
normal2
;
Stack
valor
=
(
normal1
+
5
)
*
(
normal2
-
5
)
;
repeater
suma
>
0
hit
PolloCrudo
suma
=
suma
-
1
;
dropperStack
(
suma
)
;
PolloAsado
target
valor
>=
100
hit
PolloCrudo
dropperSpider
(
"Valor grande"
)
;
PolloAsado
miss
PolloCrudo
dropperSpider
(
"Valor pequeño"
)
;
PolloAsado
dropperSpider
(
mensaje
)
;
dropperStack
(
valor
)
;
normal1
+
=
5
;
normal2
-
=
3
;
dropperStack
(
normal1
)
;
dropperStack
(
normal2
)
;
PolloAsado
worldSave
WorldName
PruebaCaracteresInvalidos
:
Bedrock
Obsidian
Stack
NORMAL
100
;
Obsidian
Stack
ÑANDU
200
;
Obsidian
Stack
AÇÚCAR
300
;
Obsidian
Stack
CAFÉ
400
;
Inventory
Stack
contador
=
0
;
Spider
mensaje
=
"Normal"
;
Stack
año
=
2025
;
Stack
piña
=
10
;
Spider
münzen
=
"Monedas"
;
Spider
öffentlich
=
"Público"
;
Stack
cont
ador
=
5
;
Spider
mens
aje
=
"Texto"
;
Stack
contador
=
10
;
Spider
mensaje
=
"Texto"
;
Stack
monedas
=
100
;
Stack
valor
=
50
;
Spider
texto
=
"Copyright"
;
Spider
texto_unicode
=
"Caracteres especiales: áéíóúñÁÉÍÓÚÑ"
;
Spider
texto_emoji
=
"Emojis: 😀🎮🌍💻"
;
Stack
a
b
;
Stack
c
d
;
Stack
e
f
;
Stack
g
h
;
Stack
valor
otro
;
Stack
valor
contador
=
5
;
Stack
otro
valor
=
10
;
Rune
char_1
=
'€'
;
Rune
char_2
=
'✓'
;
SpawnPoint
PolloCrudo
contador
=
1
;
contador
=
contador
2
;
contador
=
contador
2
;
dropperStack
(
año
)
;
dropperSpider
(
texto_unicode
)
;
contador
=
5
10
;
contador
=
5
10
;
contador
=
5
;
contador
=
contador
+
5
;
dropperSpider
(
"Fin de prueba"
)
;
PolloAsado
worldSave
WorldName
PruebaStringNoTerminado
:
Bedrock
Obsidian
Spider
NOMBRE
"Notch Engine"
;
Obsidian
Spider
VERSION
"1.0"
;
Obsidian
Spider
DESCRIPCION
"Un lenguaje basado en Minecraft;
$$ Constante después del error para verificar recuperación
Obsidian Stack MAX_NIVEL 100;
Inventory
$$ Variables con strings correctamente terminados
Spider normal = "
Este
string
está
bien
";
Spider multilinea = "
Este
string
tiene
nmúltiples
líneas
ny
está
bien
terminado
";
$$ Variable con string no terminado - falta comilla de cierre
Spider incompleto = "
Este
string
no
está
terminado
;
Stack
contador
=
0
;
Spider
confuso
=
"Este string tiene una comilla escapada \" pero no está terminado;
$$ String no terminado al final de una línea
Spider final_linea = "
Este
string
termina
la
línea
pero
no
está
cerrado
Spider
siguiente
=
"Este es un nuevo string"
;
Spider
combinado
=
"String no terminado Stack contador = 5;
$$ String con múltiples líneas pero sin terminar
Spider multilinea_incompleto = "
Este
string
tiene
múltiples
líneas
pero
no
está
terminado
correctamente
;
Spider
comentario_inmediato
=
"String terminado correctamente"
Spider
comentario_error
=
"String no terminado$$ Comentario que no salva el error
$$ String no terminado con comentario de bloque al final
Spider bloque_inmediato = "
String
no
terminado
Spider
consecutivo1
=
"Primer string terminado"
;
Spider
consecutivo2
=
"Segundo string no terminado;
Spider consecutivo3 = "
Tercer
string
terminado
";
SpawnPoint
PolloCrudo
$$ Código normal para contraste
dropperSpider("
Este
mensaje
está
bien
formado
");
$$ Instrucción con string no terminado
dropperSpider("
Este
mensaje
no
está
terminado
;
contador
=
1
;
Spider
resultado
=
normal
bind
"Parte no terminada;
$$ String no terminado en una estructura de control
target normal is "
Comparación
no
terminada
craft
hit
PolloCrudo
dropperSpider
(
"Este código nunca se ejecutará"
)
;
PolloAsado
dropperSpider
(
"String final no terminado
PolloAsado
worldSave
$*
Prueba_Err_ComentarioNoTerminado.ne
Propósito: Verificar detección de comentarios de bloque sin cierre
Fecha: 28/04/2025
*$
WorldName PruebaComentarioNoTerminado:
Bedrock
$$ Constantes normales para contraste
Obsidian Stack MAX_LEVEL 100;
$* Comentario de bloque correctamente cerrado *$
Obsidian Stack MIN_LEVEL 1;
$* Comentario de bloque sin cierre - falta el terminador *$
Obsidian Stack MEDIO_LEVEL 50;
Inventory
$$ Variables normales para contraste
Stack contador = 0;
Spider mensaje = "
Hola
Mundo
";
$*
Comentario de bloque multi-línea correctamente terminado
con varias líneas de texto
*$
Stack variable_normal = 5;
$*
Comentario de bloque multi-línea sin terminar
Este comentario no tiene el terminador correspondiente
y debería generar un error
Torch activo = On; $$ Esta línea no debería ser reconocida como código
Stack valor = 10; $$ Esta línea no debería ser reconocida como código
$$ Variables después del error para verificar recuperación
Stack recuperacion = 20;
$* Otro comentario no terminado
con símbolos que podrían confundir al analizador:
* asterisco suelto
$ signo dólar suelto
*$ esto parece un terminador pero no lo es
$* esto parece un iniciador dentro del comentario
$$ Más código después del segundo comentario no terminado
Torch otra_variable = Off;
$* Comentario aparentemente cerrado, pero con un espacio entre * y $
que debería causar que no se reconozca como terminador * $
$$ Código después del tercer comentario no terminado
Stack tercera_recuperacion = 30;
$*
Este comentario tiene una secuencia que parece un terminador,
pero tiene caracteres en medio: *texto$
Por lo tanto, no está realmente terminado.
$$ Último código para verificar recuperación
Stack ultima_recuperacion = 40;
SpawnPoint
PolloCrudo
$$ Código normal para contraste
dropperSpider("
Inicio
de
programa
");
$* Comentario de bloque sin terminar en el SpawnPoint
Esta sección del código no debería ejecutarse
contador = 5;
dropperStack(contador);
$$ Código después del comentario no terminado
Stack final = 100;
dropperStack(final);
dropperSpider("
Fin
de
programa
");
PolloAsado
$$ Esto debería ser código después del SpawnPoint, que no es válido
$$ pero el analizador léxico igual debería procesarlo como tokens
$*
Comentario final sin terminar
Este es el último elemento del archivo
worldSave
$*
Prueba: 37_Prueba_Err_CaracterNoTerminado
Descripción: Verificar detección de literales de carácter sin cierre
Fecha: 28/04/2025
*$
WorldName PruebaCaracterNoTerminado:
Inventory
$$ Casos de caracteres correctamente formados (para comparación)
Rune letraCorrecta = 'A';
Rune digitoCorrecto = '5';
Rune simboloCorrecto = '@';
Rune escapeCorrecto = '\n';
$$ Casos de caracteres sin cierre (errores léxicos)
Rune errorSimple = 'B; $$ Falta comilla de cierre
Rune errorEscape = '\n; $$ Falta comilla de cierre después de secuencia de escape
$$ Caso con apertura pero sin contenido ni cierre
Rune errorVacio = '; $$ Solo comilla de apertura
$$ Caso con múltiples caracteres (error léxico)
Rune errorMultiple = 'ABC; $$ Múltiples caracteres y falta comilla de cierre
$$ Error dentro de una expresión
Stack valor = 5 + (3 * 'x); $$ Falta comilla de cierre en la expresión
SpawnPoint
PolloCrudo
$$ Este carácter inválido debería ser detectado
Rune pruebaError = 'Z;
dropperSpider("
Este
texto
no
debería
ser
alcanzado
debido
al
error
léxico
");
PolloAsado
worldSave
$*
Prueba: 38_Prueba_Err_SimboloDesconocido
Descripción: Verificar detección de símbolos no reconocidos
Fecha: 28/04/2025
*$
WorldName PruebaSimboloDesconocido:
Bedrock
$$ Símbolos válidos para comparación
Obsidian Stack MAX_VALUE 100;
$$ Símbolo no reconocido: flecha de asignación errónea
Obsidian Stack MIN_VALUE => 0; $$ => no es un símbolo válido
Inventory
$$ Símbolos válidos (para comparación)
Stack contador = 10;
Stack resultado = contador + 5;
$$ Símbolos no reconocidos
Stack valor1 = 5 ^ 2; $$ ^ (potencia) no es un símbolo válido
Stack valor2 = 10 \ 3; $$ \ no es un operador válido
Stack valor3 = valor1 ~ valor2; $$ ~ no es un operador válido
$$ Operadores malformados o incompletos
Stack valor4 = 3 : 4; $$ : solo no es un operador válido (debe ser :+, :-, etc.)
Stack valor5 = 7 / 2; $$ / no es válido (debe ser // para división entera)
$$ Uso de símbolos de otros lenguajes
Stack valor6 = 5 ** 2; $$ ** (potencia en Python) no es válido
Torch condicion = (valor5 == valor6); $$ == no es válido (debe ser 'is')
$$ Símbolo inválido en acceso a estructura
Stack elemento = numeros->0; $$ -> no es válido para acceso (debe ser [])
ResourcePack
$$ Símbolo inválido en declaración de tipo
Anvil Stack ==> Spider; $$ ==> no es un símbolo válido (debe ser ->)
SpawnPoint
PolloCrudo
$$ Operadores inválidos en expresiones
Stack a = 5;
Stack b = 10;
Stack c = a ||| b; $$ ||| no es un operador válido
$$ Símbolos inválidos en estructuras de control
target a < b craft hit
PolloCrudo
dropperSpider("
a
es
menor
que
b
");
PolloAsado
?> $$ ?> no es un símbolo válido
$$ Símbolo inválido como terminador de instrucción
Stack valor = 100#
PolloAsado
worldSave
$*
Prueba: 39_Prueba_Comb_Estructura
Descripción: Verificar estructura básica de un programa completo
Fecha: 28/04/2025
*$
WorldName PruebaEstructuraCompleta:
$$ Sección de constantes
Bedrock
Obsidian Stack MAX_NIVEL 100;
Obsidian Spider VERSION "
1.0
.
0
";
Obsidian Torch DEBUG_MODE Off;
Obsidian Ghast PI 3.14159;
$$ Sección de tipos
ResourcePack
Anvil Ghast -> Stack truncate;
Anvil Stack -> Spider;
$$ Definición de un tipo personalizado
Entity Jugador
PolloCrudo
Spider nombre;
Stack nivel;
Ghast salud;
Torch activo;
PolloAsado;
$$ Sección de variables
Inventory
$$ Variables básicas
Stack contador = 0;
Spider mensaje = "
Bienvenido
a
Notch
Engine
";
Torch juego_activo = On;
Ghast temperatura = 21.5;
Chest letras = {: 'a', 'b', 'c' :};
$$ Variables compuestas
Shelf[5] Stack inventario;
Entity Jugador steve;
$$ Sección de prototipos
Recipe
$$ Prototipo de función
Spell calcularDanio(Stack :: nivel, arma; Ghast ref multiplicador) -> Stack;
$$ Prototipo de procedimiento
Ritual mostrarEstado(Spider :: nombre; Stack nivel, salud);
$$ Sección de implementación de rutinas
CraftingTable
$$ Implementación de función
Spell calcularDanio(Stack :: nivel, arma; Ghast ref multiplicador) -> Stack
PolloCrudo
Stack danio_base = nivel * 2;
target arma is 1 hit
PolloCrudo
danio_base *= 2; $$ Arma mejorada
PolloAsado
multiplicador = 1.5; $$ Modificar parámetro por referencia
respawn danio_base;
PolloAsado
$$ Implementación de procedimiento
Ritual mostrarEstado(Spider :: nombre; Stack nivel, salud)
PolloCrudo
dropperSpider("
==
==
=
Estado
del
Jugador
==
==
=
");
dropperSpider("
Nombre
:
" bind nombre);
dropperSpider("
Nivel
:
" bind nivel);
dropperSpider("
Salud
:
" bind salud);
dropperSpider("
==
==
==
==
==
==
==
==
==
==
==
==
==
==
=
");
PolloAsado
$$ Punto de entrada del programa
SpawnPoint
PolloCrudo
$$ Inicialización
steve@nombre = "
Steve
";
steve@nivel = 1;
steve@salud = 20.0;
steve@activo = On;
$$ Entrada y salida
dropperSpider(mensaje);
dropperSpider("
Ingrese
su
nombre
:
");
Spider nombre_jugador = hopperSpider();
$$ Uso de estructuras de control
target #(nombre_jugador) > 0 hit
PolloCrudo
dropperSpider("
Hola
,
" bind nombre_jugador bind "
");
$$ Uso de funciones y procedimientos
Stack danio = calcularDanio(steve@nivel, 1, 1.0);
dropperSpider("
Tu
daño
base
es
:
" bind danio);
ender_pearl mostrarEstado(steve@nombre, steve@nivel, steve@salud);
$$ Bucle
repeater juego_activo
PolloCrudo
dropperSpider("
Continuar
jugando
(
On
Off
)
");
juego_activo = hopperTorch();
target juego_activo hit
PolloCrudo
soulsand steve@nivel;
dropperSpider("
Nivel
aumentado
a
:
" bind steve@nivel);
PolloAsado
PolloAsado
PolloAsado
miss
PolloCrudo
dropperSpider("
Nombre
no
válido
.
");
PolloAsado
$$ Otros tipos de bucles
Stack i = 0;
spawner
PolloCrudo
soulsand i;
inventario[i] = i * 10;
PolloAsado
exhausted i >= 5;
walk j set 0 to 4
PolloCrudo
dropperSpider("
Inventario
[
" bind j bind "
]
:
" bind inventario[j]);
PolloAsado
PolloAsado
worldSave
$*
Prueba: 40_Prueba_Comb_Declaraciones
Descripción: Verificar combinaciones de declaraciones de variables y constantes
Fecha: 28/04/2025
*$
WorldName PruebaCombinacionDeclaraciones:
$$ Sección de constantes con diferentes tipos y complejidades
Bedrock
$$ Constantes simples de tipos básicos
Obsidian Stack MAX_PLAYERS 8;
Obsidian Stack MIN_LEVEL 1;
Obsidian Torch DEBUG_MODE On;
Obsidian Spider GAME_TITLE "
Notch
Engine
";
Obsidian Rune SEPARATOR '_';
Obsidian Ghast GRAVITY 9.8;
$$ Constantes con expresiones
Obsidian Stack MAX_INVENTORY_SIZE 5 * 9;
Obsidian Stack TOTAL_SLOTS MAX_PLAYERS * MAX_INVENTORY_SIZE;
Obsidian Spider FULL_TITLE GAME_TITLE bind "
v1
.
0
";
Obsidian Ghast TERMINAL_VELOCITY GRAVITY :* 3.0;
$$ Constantes con expresiones más complejas
Obsidian Stack DAYS_IN_YEAR 365;
Obsidian Stack DAYS_IN_4_YEARS DAYS_IN_YEAR * 4 + 1;
Obsidian Torch IS_LEAP_YEAR (DAYS_IN_4_YEARS - (DAYS_IN_YEAR * 4)) is 1;
$$ Declaraciones de tipos con diferentes formas
ResourcePack
$$ Conversiones de tipos básicas
Anvil Ghast -> Stack;
Anvil Ghast -> Stack truncate;
Anvil Stack -> Spider;
Anvil Rune -> Stack safe;
$$ Declaraciones de entidades (registros)
Entity Item
PolloCrudo
Spider nombre;
Stack cantidad;
Stack durabilidad;
Torch stackeable;
PolloAsado;
Entity Jugador
PolloCrudo
Spider nombre;
Stack nivel;
Stack experiencia;
Ghast salud;
Ghast hambre;
Torch en_linea;
Entity Item item_principal;
PolloAsado;
Entity Posicion
PolloCrudo
Stack x;
Stack y;
Stack z;
PolloAsado;
$$ Tipos anidados
Entity Mundo
PolloCrudo
Spider nombre;
Stack seed;
Shelf[10] Entity Jugador jugadores;
Entity Posicion spawn;
PolloAsado;
$$ Sección de variables con diferentes formas de declaración e inicialización
Inventory
$$ Declaraciones simples sin inicialización
Stack contador;
Spider mensaje;
Torch estado;
Rune inicial;
Ghast temperatura;
$$ Declaraciones con inicialización
Stack nivel = 1;
Spider nombre = "
Steve
";
Torch activo = On;
Rune tecla = 'A';
Ghast pi = 3.14159;
$$ Declaraciones múltiples del mismo tipo
Stack x = 0, y = 0, z = 0;
Torch jugando = On, pausa = Off, sonido = On;
Ghast distancia = 0.0, velocidad = 5.0, aceleracion = 1.5;
$$ Declaraciones con resultados de expresiones
Stack suma = 5 + 10;
Stack producto = 4 * 25;
Spider saludo = "
Hola
" bind nombre;
Torch condicion = nivel > 5;
Ghast promedio = (10.5 :+ 20.7 :+ 15.3) :// 3.0;
$$ Declaraciones de tipos compuestos
Shelf[5] Stack inventario;
Shelf[3] Spider mensajes = ["
Hola
", "
Mundo
", "
"];
Shelf[2] Shelf[2] Stack matriz;
Chest numeros = {: 1, 2, 3, 4, 5 :};
Book archivo = {/ "
datos
.
txt
", 'E' /};
$$ Instancias de entidades (registros)
Entity Item espada;
Entity Jugador jugador1
PolloCrudo
nombre: "
Alex
";
nivel: 5;
experiencia: 150;
salud: 18.5;
hambre: 16.0;
en_linea: On;
item_principal:
PolloCrudo
nombre: "
Espada
de
diamante
";
cantidad: 1;
durabilidad: 1500;
stackeable: Off;
PolloAsado;
PolloAsado;
Entity Mundo mundo_principal;
SpawnPoint
PolloCrudo
$$ Inicialización de variables declaradas sin valor inicial
contador = 0;
mensaje = "
Variable
inicializada
en
el
punto
de
entrada
";
estado = Off;
inicial = 'Z';
temperatura = 22.5;
$$ Inicialización de variables compuestas
espada@nombre = "
Espada
de
hierro
";
espada@cantidad = 1;
espada@durabilidad = 250;
espada@stackeable = Off;
matriz[0][0] = 1;
matriz[0][1] = 2;
matriz[1][0] = 3;
matriz[1][1] = 4;
mundo_principal@nombre = "
Mundo
de
prueba
";
mundo_principal@seed = 12345;
mundo_principal@spawn@x = 0;
mundo_principal@spawn@y = 64;
mundo_principal@spawn@z = 0;
$$ Uso de constantes en asignaciones
Stack max_jugadores = MAX_PLAYERS;
dropperSpider(FULL_TITLE);
$$ Uso de referencias a variables en asignaciones
Stack total = nivel + jugador1@nivel;
dropperSpider("
Nivel
total
:
" bind total);
PolloAsado
worldSave
$*
Prueba: 41_Prueba_Comb_Expresiones
Descripción: Verificar expresiones aritméticas y lógicas complejas
Fecha: 28/04/2025
*$
WorldName PruebaExpresionesComplejas:
Bedrock
Obsidian Stack BASE_DAMAGE 10;
Obsidian Stack ARMOR_FACTOR 2;
Obsidian Ghast CRIT_MULTIPLIER 1.5;
Obsidian Torch USE_ADVANCED_FORMULAS On;
Inventory
$$ Variables para las pruebas
Stack a = 5;
Stack b = 10;
Stack c = 15;
Stack resultado_entero;
Ghast x = 2.5;
Ghast y = 3.7;
Ghast z = 1.2;
Ghast resultado_flotante;
Torch p = On;
Torch q = Off;
Torch r = On;
Torch resultado_logico;
Spider str1 = "
Notch
";
Spider str2 = "
Engine
";
Spider resultado_string;
Shelf[5] Stack valores = [10, 20, 30, 40, 50];
Entity Jugador
PolloCrudo
Spider nombre;
Stack nivel;
Ghast salud;
PolloAsado;
Entity Jugador jugador;
SpawnPoint
PolloCrudo
$$ 1. Expresiones aritméticas complejas con enteros
resultado_entero = a + b * c;
dropperSpider("
a
+
b
*
c
=
" bind resultado_entero);
resultado_entero = (a + b) * c;
dropperSpider("
(
a
+
b
)
*
c
=
" bind resultado_entero);
resultado_entero = a + b - c * 2 // 3 % 4;
dropperSpider("
a
+
b
-
c
*
2
3
%
4
=
" bind resultado_entero);
resultado_entero = (a + (b - (c * (2 // (3 % 4)))));
dropperSpider("
Anidada
enteros
:
" bind resultado_entero);
soulsand a;
resultado_entero = a + b;
magma b;
dropperSpider("
Después
de
incremento
decremento
:
" bind resultado_entero);
$$ 2. Expresiones aritméticas complejas con flotantes
resultado_flotante = x :+ y :* z;
dropperSpider("
x
:
+
y
:
*
z
=
" bind resultado_flotante);
resultado_flotante = (x :+ y) :* z;
dropperSpider("
(
x
:
+
y
)
:
*
z
=
" bind resultado_flotante);
resultado_flotante = x :+ y :- z :* 2.0 :// 0.5 :% 1.0;
dropperSpider("
x
:
+
y
:
-
z
:
*
2.0
:
0.5
:
%
1.0
=
" bind resultado_flotante);
resultado_flotante = (x :+ (y :- (z :* (2.0 :// (0.5 :% 1.0)))));
dropperSpider("
Anidada
flotantes
:
" bind resultado_flotante);
$$ 3. Expresiones lógicas complejas
resultado_logico = p and q;
dropperSpider("
p
and
q
=
" bind resultado_logico);
resultado_logico = p or q;
dropperSpider("
p
or
q
=
" bind resultado_logico);
resultado_logico = not p;
dropperSpider("
not
p
=
" bind resultado_logico);
resultado_logico = p xor q;
dropperSpider("
p
xor
q
=
" bind resultado_logico);
resultado_logico = p and q or r;
dropperSpider("
p
and
q
or
r
=
" bind resultado_logico);
resultado_logico = p and (q or r);
dropperSpider("
p
and
(
q
or
r
)
=
" bind resultado_logico);
resultado_logico = not (p and q) or (not r and p);
dropperSpider("
not
(
p
and
q
)
or
(
not
r
and
p
)
=
" bind resultado_logico);
$$ 4. Expresiones de comparación
resultado_logico = a < b;
dropperSpider("
a
<
b
=
" bind resultado_logico);
resultado_logico = a > c;
dropperSpider("
a
>
c
=
" bind resultado_logico);
resultado_logico = a <= b and b >= c;
dropperSpider("
a
<=
b
and
b
>=
c
=
" bind resultado_logico);
resultado_logico = (a is b) or (b is c);
dropperSpider("
(
a
is
b
)
or
(
b
is
c
)
=
" bind resultado_logico);
resultado_logico = a isNot b and b isNot c and a isNot c;
dropperSpider("
a
isNot
b
and
b
isNot
c
and
a
isNot
c
=
" bind resultado_logico);
$$ 5. Expresiones mixtas (combinando tipos)
resultado_logico = (a + b > c) and (x :+ y :> z);
dropperSpider("
(
a
+
b
>
c
)
and
(
x
:
+
y
:
>
z
)
=
" bind resultado_logico);
resultado_logico = (a < b) or (not p) and (x :< y);
dropperSpider("
(
a
<
b
)
or
(
not
p
)
and
(
x
:
<
y
)
=
" bind resultado_logico);
$$ 6. Expresiones con operaciones de cadenas
resultado_string = bind(str1, "
" bind str2);
dropperSpider("
bind
result
:
" bind resultado_string);
Stack longitud = #(resultado_string);
dropperSpider("
Length
:
" bind longitud);
resultado_string = from resultado_string ## 0 ## 5;
dropperSpider("
Substring
:
" bind resultado_string);
Stack pos = seek(resultado_string, "
tch
");
dropperSpider("
Position
of
'tch'
:
" bind pos);
$$ 7. Expresiones con accesos a estructuras
Stack valor_arreglo = valores[2] + valores[3] * valores[4];
dropperSpider("
Array
expression
:
" bind valor_arreglo);
jugador@nombre = "
Steve
";
jugador@nivel = 20;
jugador@salud = 18.5;
Stack nivel_con_bonus = jugador@nivel + 5;
dropperSpider("
Nivel
con
bonus
:
" bind nivel_con_bonus);
Torch nivel_alto = jugador@nivel > 15 and jugador@salud :> 15.0;
dropperSpider("
Nivel
alto
:
" bind nivel_alto);
$$ 8. Expresiones con conversiones de tipo
Stack entero_desde_float = x >> Stack;
dropperSpider("
Entero
desde
float
:
" bind entero_desde_float);
Torch bool_desde_entero = a >> Torch;
dropperSpider("
Booleano
desde
entero
:
" bind bool_desde_entero);
$$ 9. Expresiones extremadamente complejas que combinan múltiples elementos
Stack damage = BASE_DAMAGE + ((jugador@nivel // 2) * (valores[1] + valores[3] // 3));
dropperSpider("
Daño
calculado
:
" bind damage);
target USE_ADVANCED_FORMULAS craft hit
PolloCrudo
Ghast damage_final = ((damage >> Ghast) :* CRIT_MULTIPLIER) :// (1.0 :+ ((valores[4] // 10) >> Ghast));
dropperSpider("
Daño
final
(
fórmula
avanzada
)
:
" bind damage_final);
PolloAsado
miss
PolloCrudo
Stack damage_simple = damage * 2 // (ARMOR_FACTOR + (p and q >> Stack));
dropperSpider("
Daño
final
(
fórmula
simple
)
:
" bind damage_simple);
PolloAsado
PolloAsado
worldSave
$*
Prueba: 42_Prueba_Comb_Control.ne
Descripción: Verificar estructuras de control anidadas
Fecha: 28/04/2025
*$
WorldName PruebaControlAnidado:
Inventory
$$ Variables para las pruebas
Stack contador = 0;
Stack max_iteraciones = 5;
Stack resultado = 0;
Stack opcion = 2;
Torch condicion1 = On;
Torch condicion2 = Off;
Spider mensaje = "
Estructuras
de
control
anidadas
";
Spider resultado_texto = "
";
Shelf[5] Stack matriz = [1, 2, 3, 4, 5];
Entity Personaje
PolloCrudo
Spider nombre;
Stack nivel;
Torch activo;
PolloAsado;
Entity Personaje jugador;
SpawnPoint
dropperSpider(mensaje);
jugador@nombre = "
Steve
";
jugador@nivel = 1;
jugador@activo = On;
$$ 1. Condicionales anidados (if-then-else)
target jugador@nivel >= 1 craft hit
PolloCrudo
dropperSpider("
Nivel
suficiente
para
comenzar
");
target jugador@activo craft hit
PolloCrudo
dropperSpider("
Jugador
activo
");
target jugador@nombre is "
Steve
" craft hit
PolloCrudo
dropperSpider("
Bienvenido
,
Steve
");
soulsand jugador@nivel;
PolloAsado
miss
PolloCrudo
dropperSpider("
Bienvenido
,
jugador
desconocido
");
PolloAsado
PolloAsado
miss
PolloCrudo
dropperSpider("
Jugador
inactivo
.
Activando
.
.
.
");
jugador@activo = On;
PolloAsado
PolloAsado
miss
PolloCrudo
dropperSpider("
Nivel
insuficiente
para
comenzar
");
PolloAsado
$$ 2. Switch anidado dentro de if
target opcion > 0 craft hit
PolloCrudo
jukebox opcion craft
disc 1:
PolloCrudo
dropperSpider("
Opción
1
seleccionada
");
target condicion1 craft hit
PolloCrudo
dropperSpider("
Subopción
A
");
PolloAsado
miss
PolloCrudo
dropperSpider("
Subopción
B
");
PolloAsado
PolloAsado
disc 2:
PolloCrudo
dropperSpider("
Opción
2
seleccionada
");
jukebox jugador@nivel craft
disc 1:
PolloCrudo
dropperSpider("
Nivel
básico
");
PolloAsado
disc 2:
PolloCrudo
dropperSpider("
Nivel
intermedio
");
PolloAsado
silence:
PolloCrudo
dropperSpider("
Nivel
desconocido
");
PolloAsado
PolloAsado
silence:
PolloCrudo
dropperSpider("
Opción
no
reconocida
");
PolloAsado
PolloAsado
$$ 3. Bucles anidados - while dentro de for
walk i set 0 to 2 craft
PolloCrudo
dropperSpider("
Iteración
de
for
principal
:
" bind i);
Stack j = 0;
repeater j < 3 craft
PolloCrudo
dropperSpider("
Subiteración
de
while
:
" bind j);
resultado += (i * 10 + j);
soulsand j;
PolloAsado
PolloAsado
dropperSpider("
Resultado
acumulado
:
" bind resultado);
$$ 4. Bucle do-while con if anidado
contador = 0;
resultado = 0;
spawner
PolloCrudo
soulsand contador;
dropperSpider("
Iteración
do
-
while
:
" bind contador);
target contador % 2 is 0 craft hit
PolloCrudo
dropperSpider("
Número
par
detectado
");
resultado += contador;
PolloAsado
miss
PolloCrudo
dropperSpider("
Número
impar
detectado
");
resultado += contador * 2;
PolloAsado
PolloAsado
exhausted contador >= max_iteraciones;
dropperSpider("
Resultado
tras
do
-
while
:
" bind resultado);
$$ 5. Bucles for anidados con break y continue
resultado = 0;
walk i set 0 to 5 craft
PolloCrudo
target i is 3 craft hit
PolloCrudo
dropperSpider("
Saltando
iteración
i
=
3
");
enderPearl;
PolloAsado
dropperSpider("
For
externo
:
" bind i);
walk j set 0 to 3 craft
PolloCrudo
target i is 4 and j > 1 craft hit
PolloCrudo
dropperSpider("
Terminando
loop
interno
en
i
=
4
,
j
=
" bind j);
creeper;
PolloAsado
resultado += (i + j);
dropperSpider("
For
interno
:
j
=
" bind j bind "
,
suma
acumulada
=
" bind resultado);
PolloAsado
PolloAsado
$$ 6. Combinación compleja: with dentro de if-else dentro de while
contador = 0;
resultado = 0;
repeater contador < 3 craft
PolloCrudo
soulsand contador;
dropperSpider("
Iteración
while
principal
:
" bind contador);
target contador % 2 is 0 craft hit
PolloCrudo
wither jugador craft
PolloCrudo
activo = Off;
dropperSpider("
" bind nombre bind "
desactivado
temporalmente
");
spawner
PolloCrudo
soulsand nivel;
dropperSpider("
Incrementando
nivel
:
" bind nivel);
PolloAsado
exhausted nivel > contador + 2;
activo = On;
dropperSpider("
" bind nombre bind "
reactivado
con
nivel
" bind nivel);
PolloAsado
PolloAsado
miss
PolloCrudo
Stack temp_nivel = jugador@nivel;
repeater temp_nivel > 0 craft
PolloCrudo
dropperSpider("
Reduciendo
nivel
temporal
:
" bind temp_nivel);
target temp_nivel is 1 craft hit
PolloCrudo
dropperSpider("
Nivel
mínimo
alcanzado
");
creeper;
PolloAsado
magma temp_nivel;
PolloAsado
PolloAsado
PolloAsado
$$ 7. Estructuras de control con expresiones complejas en las condiciones
walk i set 0 to matriz[2] + matriz[4] // 2 craft
PolloCrudo
target (i * 2 <= matriz[i % 5]) and ((i % 2 is 0) or (i is matriz[0])) craft hit
PolloCrudo
dropperSpider("
Condición
compleja
satisfecha
en
i
=
" bind i);
resultado += i;
PolloAsado
PolloAsado
dropperSpider("
Resultado
final
:
" bind resultado);
$$ 8. Instrucción ragequit condicionada anidada
target contador >= max_iteraciones and resultado < 100 craft hit
PolloCrudo
target jugador@nivel < 5 craft hit
PolloCrudo
dropperSpider("
Condiciones
críticas
alcanzadas
.
Terminando
programa
.
");
ragequit;
PolloAsado
PolloAsado
dropperSpider("
Programa
completado
con
éxito
.
");
worldSave
$*
Prueba: 43_Prueba_Rend_MuchosTokens
Descripción: Verificar rendimiento con un archivo con miles de tokens
Fecha: 28/04/2025
*$
WorldName PruebaMuchosTokens:
Bedrock
Obsidian Stack MAX_ITERATIONS 1000;
Obsidian Stack ARRAY_SIZE 500;
Obsidian Stack STEP_VALUE 1;
Obsidian Spider TEST_NAME "
Prueba
de
rendimiento
con
muchos
tokens
";
ResourcePack
Entity TestData
PolloCrudo
Stack id;
Stack value;
Ghast weight;
Spider name;
Torch active;
PolloAsado;
Inventory
$$ Declaramos variables extensas para generar muchos tokens
Shelf[500] Stack numbers;
$$ Creamos un array grande de registros
Shelf[100] Entity TestData records;
$$ Variables para el procesamiento
Stack counter;
Stack sum;
Stack product;
Stack max_value;
Stack min_value;
Ghast average;
Stack i;
Stack j;
Stack k;
Stack temp;
Torch condition;
SpawnPoint
dropperSpider(TEST_NAME);
dropperSpider("
Inicializando
arrays
.
.
.
");
$$ Inicialización masiva del array de enteros
walk i set 0 to ARRAY_SIZE - 1 craft
PolloCrudo
numbers[i] = i * STEP_VALUE;
PolloAsado
$$ Inicialización del array de registros
walk i set 0 to 99 craft
PolloCrudo
records[i]@id = i;
records[i]@value = i * 10;
records[i]@weight = i :* 0.5;
records[i]@name = "
Item_
" bind i;
records[i]@active = i % 2 is 0;
PolloAsado
dropperSpider("
Realizando
cálculos
.
.
.
");
$$ Cálculos repetitivos generando miles de tokens
sum = 0;
product = 1;
max_value = numbers[0];
min_value = numbers[0];
$$ Bucle con muchas operaciones
walk i set 0 to ARRAY_SIZE - 1 craft
PolloCrudo
$$ Acumuladores simples
sum += numbers[i];
$$ Para evitar overflow, sólo multiplicamos los primeros 10 valores
target i < 10 craft hit
PolloCrudo
product *= numbers[i] + 1;
PolloAsado
$$ Cálculo de máximo y mínimo
target numbers[i] > max_value craft hit
PolloCrudo
max_value = numbers[i];
PolloAsado
target numbers[i] < min_value craft hit
PolloCrudo
min_value = numbers[i];
PolloAsado
$$ Operaciones condicionales adicionales
target i % 50 is 0 craft hit
PolloCrudo
dropperSpider("
Procesado
" bind i bind "
elementos
.
.
.
");
PolloAsado
PolloAsado
$$ Cálculo de promedio
average = sum >> Ghast :// (ARRAY_SIZE >> Ghast);
dropperSpider("
Procesamiento
completado
.
Resultados
:
");
dropperSpider("
Suma
total
:
" bind sum);
dropperSpider("
Producto
(
primeros
10
)
:
" bind product);
dropperSpider("
Valor
máximo
:
" bind max_value);
dropperSpider("
Valor
mínimo
:
" bind min_value);
dropperSpider("
Promedio
:
" bind average);
$$ Procesamiento de registros - para generar más tokens
dropperSpider("
Procesando
registros
.
.
.
");
counter = 0;
walk i set 0 to 99 craft
PolloCrudo
target records[i]@active craft hit
PolloCrudo
soulsand counter;
$$ Actualizar el valor basado en otros registros
walk j set 0 to i craft
PolloCrudo
records[i]@value += j;
PolloAsado
PolloAsado
PolloAsado
dropperSpider("
Registros
activos
:
" bind counter);
$$ Algoritmo de ordenamiento burbuja para generar aún más tokens
dropperSpider("
Ordenando
array
.
.
.
");
walk i set 0 to ARRAY_SIZE - 2 craft
PolloCrudo
walk j set 0 to ARRAY_SIZE - i - 2 craft
PolloCrudo
target numbers[j] > numbers[j + 1] craft hit
PolloCrudo
$$ Intercambio
temp = numbers[j];
numbers[j] = numbers[j + 1];
numbers[j + 1] = temp;
PolloAsado
PolloAsado
PolloAsado
dropperSpider("
Array
ordenado
.
");
$$ Búsqueda binaria para generar más tokens
dropperSpider("
Realizando
búsquedas
.
.
.
");
walk k set 0 to 20 craft
PolloCrudo
Stack valor_buscar = k * 25;
Stack inicio = 0;
Stack fin = ARRAY_SIZE - 1;
Stack medio;
Stack encontrado = 0;
repeater inicio <= fin craft
PolloCrudo
medio = (inicio + fin) // 2;
target numbers[medio] is valor_buscar craft hit
PolloCrudo
encontrado = 1;
creeper;
PolloAsado
target numbers[medio] < valor_buscar craft hit
PolloCrudo
inicio = medio + 1;
PolloAsado
miss
PolloCrudo
fin = medio - 1;
PolloAsado
PolloAsado
target encontrado craft hit
PolloCrudo
dropperSpider("
Valor
" bind valor_buscar bind "
encontrado
en
posición
" bind medio);
PolloAsado
miss
PolloCrudo
dropperSpider("
Valor
" bind valor_buscar bind "
no
encontrado
");
PolloAsado
PolloAsado
dropperSpider("
Prueba
de
rendimiento
completada
.
");
worldSave
$*
Prueba: 44_Prueba_Rend_TokensRepetidos
Descripción: Verificar rendimiento con patrones repetitivos
Fecha: 28/04/2025
*$
WorldName PruebaTokensRepetidos:
Bedrock
Obsidian Stack MAX_ITERATIONS 500;
Obsidian Stack PATTERN_LENGTH 20;
Inventory
$$ Variables para la prueba
Stack counter = 0;
Stack total = 0;
Stack temp = 0;
Torch flag = On;
SpawnPoint
dropperSpider("
Iniciando
prueba
de
rendimiento
con
tokens
repetitivos
");
$$ =================================================================
$$ Patrón 1: Repetición masiva de operaciones aritméticas
$$ =================================================================
counter = 0;
total = 0;
repeater counter < MAX_ITERATIONS craft
PolloCrudo
$$ Patrón de operaciones aritméticas que se repite
total = total + 1;
total = total - 1;
total = total + 2;
total = total - 1;
total = total + 3;
total = total - 2;
total = total * 2;
total = total // 2;
total = total + 5;
total = total % 10;
total = total + 1;
total = total - 1;
total = total + 2;
total = total - 1;
total = total + 3;
total = total - 2;
total = total * 2;
total = total // 2;
total = total + 5;
total = total % 10;
soulsand counter;
PolloAsado
dropperSpider("
Patrón
1
completado
.
Total
:
" bind total);
$$ =================================================================
$$ Patrón 2: Repetición masiva de operaciones lógicas
$$ =================================================================
counter = 0;
flag = On;
repeater counter < MAX_ITERATIONS craft
PolloCrudo
$$ Patrón de operaciones lógicas que se repite
flag = flag and On;
flag = flag or Off;
flag = not flag;
flag = flag and On;
flag = flag or Off;
flag = not flag;
flag = flag xor On;
flag = flag xor Off;
flag = flag and On;
flag = not flag;
flag = flag and On;
flag = flag or Off;
flag = not flag;
flag = flag and On;
flag = flag or Off;
flag = not flag;
flag = flag xor On;
flag = flag xor Off;
flag = flag and On;
flag = not flag;
soulsand counter;
PolloAsado
dropperSpider("
Patrón
2
completado
.
Estado
final
:
" bind flag);
$$ =================================================================
$$ Patrón 3: Repetición masiva de evaluaciones condicionales
$$ =================================================================
counter = 0;
total = 0;
repeater counter < MAX_ITERATIONS craft
PolloCrudo
$$ Patrón de condicionales que se repite
target counter % 2 is 0 craft hit
PolloCrudo
total += 1;
PolloAsado
miss
PolloCrudo
total += 2;
PolloAsado
target counter % 3 is 0 craft hit
PolloCrudo
total += 3;
PolloAsado
miss
PolloCrudo
total += 1;
PolloAsado
target counter % 5 is 0 craft hit
PolloCrudo
total += 5;
PolloAsado
miss
PolloCrudo
total += 2;
PolloAsado
target counter % 7 is 0 craft hit
PolloCrudo
total += 7;
PolloAsado
miss
PolloCrudo
total += 3;
PolloAsado
target total > 1000 craft hit
PolloCrudo
total = total % 1000;
PolloAsado
soulsand counter;
PolloAsado
dropperSpider("
Patrón
3
completado
.
Total
:
" bind total);
$$ =================================================================
$$ Patrón 4: Repetición masiva de incremento/decremento
$$ =================================================================
counter = 0;
total = 500;
repeater counter < MAX_ITERATIONS craft
PolloCrudo
$$ Patrón de incremento/decremento que se repite
soulsand total;
soulsand total;
soulsand total;
magma total;
magma total;
soulsand total;
soulsand total;
magma total;
soulsand total;
magma total;
soulsand total;
soulsand total;
soulsand total;
magma total;
magma total;
soulsand total;
soulsand total;
magma total;
soulsand total;
magma total;
soulsand counter;
PolloAsado
dropperSpider("
Patrón
4
completado
.
Total
:
" bind total);
$$ =================================================================
$$ Patrón 5: Repetición masiva de operaciones de asignación compuesta
$$ =================================================================
counter = 0;
total = 5;
repeater counter < MAX_ITERATIONS craft
PolloCrudo
$$ Patrón de asignaciones compuestas que se repite
total += 5;
total -= 2;
total *= 2;
total //= 2;
total %= 10;
total += 1;
total -= 1;
total *= 3;
total //= 3;
total %= 5;
total += 5;
total -= 2;
total *= 2;
total //= 2;
total %= 10;
total += 1;
total -= 1;
total *= 3;
total //= 3;
total %= 5;
soulsand counter;
PolloAsado
dropperSpider("
Patrón
5
completado
.
Total
:
" bind total);
$$ =================================================================
$$ Patrón 6: Repetición masiva de operadores de comparación
$$ =================================================================
counter = 0;
total = 0;
temp = 50;
repeater counter < MAX_ITERATIONS craft
PolloCrudo
$$ Patrón de comparaciones que se repite
target counter < temp craft hit total += 1; PolloAsado
target counter > temp craft hit total += 1; PolloAsado
target counter <= temp craft hit total += 1; PolloAsado
target counter >= temp craft hit total += 1; PolloAsado
target counter is temp craft hit total += 1; PolloAsado
target counter isNot temp craft hit total += 1; PolloAsado
target counter < 100 craft hit total += 1; PolloAsado
target counter > 0 craft hit total += 1; PolloAsado
target counter <= 100 craft hit total += 1; PolloAsado
target counter >= 0 craft hit total += 1; PolloAsado
target counter < temp craft hit total += 1; PolloAsado
target counter > temp craft hit total += 1; PolloAsado
target counter <= temp craft hit total += 1; PolloAsado
target counter >= temp craft hit total += 1; PolloAsado
target counter is temp craft hit total += 1; PolloAsado
target counter isNot temp craft hit total += 1; PolloAsado
target counter < 100 craft hit total += 1; PolloAsado
target counter > 0 craft hit total += 1; PolloAsado
target counter <= 100 craft hit total += 1; PolloAsado
target counter >= 0 craft hit total += 1; PolloAsado
soulsand counter;
PolloAsado
dropperSpider("
Patrón
6
completado
.
Total
:
" bind total);
dropperSpider("
Prueba
de
rendimiento
con
tokens
repetitivos
completada
.
");
worldSave
$*
Prueba: 45_Prueba_Rend_TokensVariados
Descripción: Verificar rendimiento con variedad de tokens mezclados
Fecha: 28/04/2025
*$
WorldName PruebaTokensVariados:
$$ Sección de constantes para controlar el tamaño de la prueba
Bedrock
Obsidian Stack ITERATIONS 100;
Obsidian Stack MAX_VALUE 1000;
Obsidian Stack ARRAY_SIZE 50;
Obsidian Spider TEST_NAME "
Prueba
de
rendimiento
con
tokens
variados
";
Obsidian Spider VERSION "
1.0
";
Obsidian Ghast PI 3.14159;
Obsidian Torch DEBUG_MODE On;
$$ Definiciones de tipos variados para generar diversidad de tokens
ResourcePack
Entity Posicion
PolloCrudo
Stack x;
Stack y;
Stack z;
PolloAsado;
Entity Item
PolloCrudo
Spider nombre;
Stack cantidad;
Stack durabilidad;
Ghast peso;
Torch consumible;
PolloAsado;
Entity Jugador
PolloCrudo
Spider nombre;
Stack nivel;
Ghast salud;
Entity Posicion posicion;
Shelf[10] Entity Item inventario;
PolloAsado;
Anvil Ghast -> Stack truncate;
Anvil Stack -> Spider;
Anvil Spider -> Stack;
Anvil Stack -> Torch;
Inventory
Stack contador = 0;
Stack suma = 0;
Stack producto = 1;
Ghast pi = 3.14159;
Ghast e = 2.71828;
Ghast resultado_flotante = 0.0;
Spider texto = "
Prueba
de
rendimiento
";
Spider resultado_texto = "
";
Rune caracter = 'A';
Torch condicion = On;
Shelf[ARRAY_SIZE] Stack numeros;
Shelf[ARRAY_SIZE] Ghast valores_reales;
Shelf[10] Spider textos = ["
uno
", "
dos
", "
tres
", "
cuatro
", "
cinco
", "
seis
", "
siete
", "
ocho
", "
nueve
", "
diez
"];
Chest conjunto_numeros = {: 1, 2, 3, 4, 5 :};
Chest conjunto_caracteres = {: 'a', 'b', 'c', 'd', 'e' :};
Book archivo_log = {/ "
log
.
txt
", 'E' /};
Book archivo_datos = {/ "
datos
.
dat
", 'L' /};
Entity Posicion origen
PolloCrudo
x: 0;
y: 0;
z: 0;
PolloAsado;
Entity Item espada
PolloCrudo
nombre: "
Espada
de
diamante
";
cantidad: 1;
durabilidad: 1000;
peso: 5.0;
consumible: Off;
PolloAsado;
Entity Jugador jugador_principal;
Entity Jugador jugadores[5];
Recipe
Spell calcularDanio(Stack :: nivel; Ghast :: multiplicador) -> Stack;
Spell distanciaEntre(Entity Posicion :: pos1, pos2) -> Ghast;
Spell crearItem(Spider :: nombre; Stack cantidad, durabilidad; Ghast peso; Torch consumible) -> Entity Item;
Ritual inicializarJugador(Entity Jugador ref jugador; Spider :: nombre; Stack nivel; Ghast salud);
Ritual mostrarEstadisticas(Entity Jugador :: jugador);
Ritual procesarInventario(Shelf[10] Entity Item :: inventario);
CraftingTable
Spell calcularDanio(Stack :: nivel; Ghast :: multiplicador) -> Stack
PolloCrudo
Stack danio_base = nivel * 2 + 5;
Stack danio_final = danio_base;
target nivel > 10 craft hit
PolloCrudo
danio_final += (nivel - 10) * 3;
PolloAsado
Ghast temp = danio_final >> Ghast;
temp = temp :* multiplicador;
danio_final = temp >> Stack;
respawn danio_final;
PolloAsado
Spell distanciaEntre(Entity Posicion :: pos1, pos2) -> Ghast
PolloCrudo
Stack dx = pos1@x - pos2@x;
Stack dy = pos1@y - pos2@y;
Stack dz = pos1@z - pos2@z;
Ghast dx_float = dx >> Ghast;
Ghast dy_float = dy >> Ghast;
Ghast dz_float = dz >> Ghast;
Ghast suma_cuadrados = (dx_float :* dx_float) :+ (dy_float :* dy_float) :+ (dz_float :* dz_float);
Ghast result = suma_cuadrados :// 2.0;
respawn result;
PolloAsado
Spell crearItem(Spider :: nombre; Stack cantidad, durabilidad; Ghast peso; Torch consumible) -> Entity Item
PolloCrudo
Entity Item nuevo_item
PolloCrudo
nombre: nombre;
cantidad: cantidad;
durabilidad: durabilidad;
peso: peso;
consumible: consumible;
PolloAsado;
respawn nuevo_item;
PolloAsado
Ritual inicializarJugador(Entity Jugador ref jugador; Spider :: nombre; Stack nivel; Ghast salud)
PolloCrudo
jugador@nombre = nombre;
jugador@nivel = nivel;
jugador@salud = salud;
jugador@posicion@x = 0;
jugador@posicion@y = 0;
jugador@posicion@z = 0;
walk i set 0 to 9 craft
PolloCrudo
jugador@inventario[i] = crearItem("
Item_
" bind i, i + 1, 100 * (i + 1), i :* 0.5, i % 2 is 0);
PolloAsado
PolloAsado
Ritual mostrarEstadisticas(Entity Jugador :: jugador)
PolloCrudo
dropperSpider("
==
=
Estadísticas
del
Jugador
==
=
");
dropperSpider("
Nombre
:
" bind jugador@nombre);
dropperSpider("
Nivel
:
" bind jugador@nivel);
dropperSpider("
Salud
:
" bind jugador@salud);
dropperSpider("
Posición
:
(
" bind jugador@posicion@x bind "
,
" bind jugador@posicion@y bind "
,
" bind jugador@posicion@z bind "
)
");
dropperSpider("
Inventario
:
" bind #(jugador@inventario) bind "
items
");
PolloAsado
Ritual procesarInventario(Shelf[10] Entity Item :: inventario)
PolloCrudo
Stack total_items = 0;
Ghast peso_total = 0.0;
Spider lista_items = "
";
walk i set 0 to 9 craft
PolloCrudo
total_items += inventario[i]@cantidad;
peso_total = peso_total :+ (inventario[i]@peso :* inventario[i]@cantidad >> Ghast);
target i < 9 craft hit
PolloCrudo
lista_items = lista_items bind inventario[i]@nombre bind "
,
";
PolloAsado
miss
PolloCrudo
lista_items = lista_items bind inventario[i]@nombre;
PolloAsado
PolloAsado
dropperSpider("
Total
items
:
" bind total_items);
dropperSpider("
Peso
total
:
" bind peso_total);
dropperSpider("
Lista
:
" bind lista_items);
PolloAsado
SpawnPoint
dropperSpider(TEST_NAME bind "
v
" bind VERSION);
walk i set 0 to ARRAY_SIZE - 1 craft
PolloCrudo
numeros[i] = (i * i + i) % MAX_VALUE;
valores_reales[i] = i :* PI :// 10.0;
target i < 20 craft hit
PolloCrudo
add(conjunto_numeros, i * 10);
PolloAsado
PolloAsado
jugador_principal@nombre = "
Aventurero
";
jugador_principal@nivel = 25;
jugador_principal@salud = 95.5;
jugador_principal@posicion@x = 100;
jugador_principal@posicion@y = 64;
jugador_principal@posicion@z = -50;
walk i set 0 to 4 craft
PolloCrudo
Spider nombre_jugador = "
Jugador_
" bind i;
Stack nivel_inicial = 1 + i * 5;
Ghast salud_inicial = 20.0 :+ (i :* 5.0);
ender_pearl inicializarJugador(jugadores[i], nombre_jugador, nivel_inicial, salud_inicial);
PolloAsado
dropperSpider("
Realizando
operaciones
mezcladas
.
.
.
");
contador = 0;
suma = 0;
producto = 1;
resultado_texto = "
";
walk iteracion set 0 to ITERATIONS - 1 craft
PolloCrudo
Stack indice = iteracion % ARRAY_SIZE;
suma += numeros[indice];
target producto < 1000000 craft hit
PolloCrudo
producto *= (indice + 1);
PolloAsado
Ghast valor_real = valores_reales[indice];
resultado_flotante = resultado_flotante :+ valor_real;
target resultado_flotante :> 1000.0 craft hit
PolloCrudo
resultado_flotante = resultado_flotante :% 1000.0;
PolloAsado
Spider texto_iteracion = textos[iteracion % 10];
target iteracion % 5 is 0 craft hit
PolloCrudo
resultado_texto = resultado_texto bind texto_iteracion;
PolloAsado
target iteracion % 2 is 0 craft hit
PolloCrudo
caracter = etchUp(caracter);
PolloAsado
miss
PolloCrudo
caracter = etchDown(caracter);
PolloAsado
condicion = condicion xor (iteracion % 3 is 0);
target indice % 2 is 0 and condicion craft hit
PolloCrudo
soulsand contador;
PolloAsado
target iteracion % 10 is 0 craft hit
PolloCrudo
Stack danio = calcularDanio(jugador_principal@nivel, 1.5);
Ghast distancia = distanciaEntre(jugador_principal@posicion, origen);
dropperSpider("
Iteración
" bind iteracion bind "
:
Daño
=
" bind danio bind "
,
Distancia
=
" bind distancia);
PolloAsado
Stack jugador_indice = iteracion % 5;
soulsand jugadores[jugador_indice]@nivel;
target iteracion % 20 is 0 craft hit
PolloCrudo
ender_pearl mostrarEstadisticas(jugadores[jugador_indice]);
PolloAsado
PolloAsado
dropperSpider("
Prueba
completada
.
Resultados
:
");
dropperSpider("
Suma
total
:
" bind suma);
dropperSpider("
Producto
acumulado
:
" bind producto);
dropperSpider("
Resultado
flotante
:
" bind resultado_flotante);
dropperSpider("
Texto
resultante
:
" bind resultado_texto);
dropperSpider("
Caracter
final
:
" bind caracter);
dropperSpider("
Contador
incrementado
:
" bind contador);
dropperSpider("
Estado
de
condición
final
:
" bind condicion);
ender_pearl procesarInventario(jugador_principal@inventario);
dropperSpider("
Prueba
de
rendimiento
con
tokens
variados
finalizada
");
worldSave
$*
Prueba_PR_Estructura.ne
Propósito: Verificar el reconocimiento de palabras reservadas de estructura del programa
Probar: WorldName, Bedrock, ResourcePack, Inventory, Recipe, CraftingTable, SpawnPoint
Fecha: 28/04/2025
*$
$$ Prueba de la estructura básica del programa NotchEngine
$$ Verificando las palabras reservadas: WorldName, Bedrock, ResourcePack, Inventory, Recipe, CraftingTable, SpawnPoint
WorldName PruebaEstructura:
Bedrock
Obsidian Stack MAX_VALOR 100;
Obsidian Spider SALUDO "
Prueba
de
estructura
";
ResourcePack
Anvil Stack -> Spider;
Inventory
Stack contador = 0;
Spider mensaje = "
Hola
mundo
";
Recipe
Spell sumar(Stack :: a, b) -> Stack;
Ritual mostrarMensaje(Spider :: texto);
CraftingTable
Spell sumar(Stack :: a, b) -> Stack
PolloCrudo
Stack resultado = a + b;
respawn resultado;
PolloAsado
Ritual mostrarMensaje(Spider :: texto)
PolloCrudo
dropperSpider(texto);
PolloAsado
SpawnPoint
PolloCrudo
dropperSpider(SALUDO);
Stack resultado = sumar(5, 10);
dropperSpider("
El
resultado
es
:
" bind resultado);
PolloAsado
worldSave
$*
Prueba_PR_Tipos.ne
Propósito: Verificar reconocimiento de tipos de datos en NotchEngine
Probar: Stack, Rune, Spider, Torch, Chest, Book, Ghast, Shelf, Entity
Fecha: 28/04/2025
*$
$$ Prueba de los tipos de datos en NotchEngine
$$ Verificando: Stack, Rune, Spider, Torch, Chest, Book, Ghast, Shelf, Entity
WorldName PruebaTipos:
Inventory
$$ Declaraciones de variables de cada tipo
$$ Stack - Tipo de dato entero
Stack entero = 42;
$$ Rune - Tipo de dato carácter
Rune caracter = 'N';
$$ Spider - Tipo de dato string
Spider texto = "
NotchEngine
";
$$ Torch - Tipo de dato booleano
Torch verdadero = On;
Torch falso = Off;
$$ Chest - Tipo de dato conjunto
Chest numeros = {: 1, 2, 3, 4, 5 :};
$$ Book - Tipo de dato archivo de texto
Book archivo = {/ "
datos
.
txt
", 'E' /};
$$ Ghast - Tipo de datos números flotantes
Ghast decimal = 3.14159;
$$ Shelf - Tipo de dato arreglos
Shelf[5] Stack arreglo = [1, 2, 3, 4, 5];
$$ Entity - Tipo de dato registros
Entity Jugador
PolloCrudo
Spider nombre;
Stack nivel;
Ghast salud;
PolloAsado;
Entity Jugador jugador = {nombre: "
Steve
", nivel: 1, salud: 20.0};
SpawnPoint
PolloCrudo
dropperSpider("
Prueba
de
tipos
completada
");
PolloAsado
worldSave
$*
Prueba_PR_Booleanos.ne
Propósito: Verificar reconocimiento de literales booleanas (On, Off)
Probar: Torch, And, Or, Not
Fecha: 28/04/2025
*$
$$ Prueba de literales booleanas en NotchEngine
$$ Verificando: On, Off
WorldName PruebaBooleanos:
Bedrock
Obsidian Torch VERDADERO On;
Obsidian Torch FALSO Off;
Inventory
$$ Declaración e inicialización con valores booleanos
Torch activo = On;
Torch inactivo = Off;
$$ Variables para almacenar resultados de operaciones lógicas
Torch resultado1;
Torch resultado2;
Torch resultado3;
Torch resultado4;
Torch resultado5;
SpawnPoint
PolloCrudo
$$ Mostrar valores booleanos directos
dropperSpider("
Valor
de
On
:
");
dropperTorch(On);
dropperSpider("
Valor
de
Off
:
");
dropperTorch(Off);
$$ Operaciones lógicas con literales booleanas
resultado1 = On and On;
dropperSpider("
On
and
On
:
");
dropperTorch(resultado1);
resultado2 = On and Off;
dropperSpider("
On
and
Off
:
");
dropperTorch(resultado2);
resultado3 = On or Off;
dropperSpider("
On
or
Off
:
");
dropperTorch(resultado3);
resultado4 = Off or Off;
dropperSpider("
Off
or
Off
:
");
dropperTorch(resultado4);
resultado5 = not On;
dropperSpider("
not
On
:
");
dropperTorch(resultado5);
$$ Uso en estructuras de control
target On craft hit
PolloCrudo
dropperSpider("
Condición
On
es
verdadera
");
PolloAsado
target Off craft hit
PolloCrudo
dropperSpider("
Esto
no
debería
mostrarse
");
PolloAsado
miss
PolloCrudo
dropperSpider("
Condición
Off
es
falsa
");
PolloAsado
PolloAsado
worldSave
$*
Prueba_PR_Bloques.ne
Propósito: Verificar reconocimiento de delimitadores de bloques (PolloCrudo, PolloAsado)
Probar: PolloCrudo, PolloAsado
Fecha: 28/04/2025
*$
$$ Prueba de delimitadores de bloques en NotchEngine
$$ Verificando: PolloCrudo, PolloAsado
WorldName PruebaBloques:
Inventory
$$ Variables para las pruebas
Stack contador = 0;
Stack acumulador = 0;
Stack resultado = 0;
Spider mensaje = "
Prueba
de
bloques
PolloCrudo
y
PolloAsado
";
CraftingTable
$$ Función con bloques de código
Spell sumarPares(Stack :: limite) -> Stack
PolloCrudo
Stack suma = 0;
$$ Bloque anidado dentro de una estructura de control
walk i set 1 to limite craft
PolloCrudo
target i % 2 is 0 craft hit
PolloCrudo
suma += i;
PolloAsado
PolloAsado
respawn suma;
PolloAsado
$$ Función con diferentes niveles de anidamiento de bloques
Spell calcularFactorial(Stack :: n) -> Stack
PolloCrudo
target n <= 1 craft hit
PolloCrudo
respawn 1;
PolloAsado
$$ Bloque dentro de una expresión
Stack resultado = n * calcularFactorial(n - 1);
respawn resultado;
PolloAsado
SpawnPoint
$$ Bloque principal
PolloCrudo
$$ Bloque simple
PolloCrudo
contador = 5;
dropperSpider(mensaje);
PolloAsado
$$ Bloque dentro de una estructura repeater
repeater contador > 0 craft
PolloCrudo
acumulador += contador;
magma contador;
$$ Bloque anidado dentro de un condicional dentro de un bucle
target contador is 2 craft hit
PolloCrudo
dropperSpider("
Contador
es
igual
a
2
");
$$ Otro bloque más anidado
PolloCrudo
dropperSpider("
Este
es
un
bloque
muy
anidado
");
PolloAsado
PolloAsado
PolloAsado
$$ Uso de bloques en estructura condicional
target acumulador > 10 craft hit
PolloCrudo
dropperSpider("
Acumulador
es
mayor
que
10
");
PolloAsado
miss
PolloCrudo
dropperSpider("
Acumulador
es
menor
o
igual
a
10
");
PolloAsado
$$ Bloque en estructura spawner-exhausted
spawner
PolloCrudo
soulsand resultado;
target resultado > 5 craft hit creeper;
PolloAsado
exhausted resultado > 10;
dropperSpider("
Valor
final
del
resultado
:
" bind resultado);
PolloAsado
worldSave
$*
Prueba_PR_Control.ne
Propósito: Verificar reconocimiento de palabras de control de flujo
Probar: Entity, PolloCrudo, PolloAsado, Punto, SpawnPoint, Inventory, WorldName
Fecha: 28/04/2025
*$
$$ Prueba de palabras reservadas de control de flujo en NotchEngine
$$ Verificando: repeater, craft, target, hit, miss, jukebox, disc, silence,
$$ spawner, exhausted, walk, set, to, step, wither
WorldName PruebaControl:
Inventory
$$ Variables para las pruebas
Stack contador = 0;
Stack opcion = 2;
Torch condicion = On;
Stack iterador = 0;
Entity Punto
PolloCrudo
Stack x;
Stack y;
PolloAsado;
Entity Punto coordenada;
SpawnPoint
PolloCrudo
$$ 1. Prueba de repeater (while) con craft
dropperSpider("
Prueba
de
repeater
:
");
contador = 5;
repeater contador > 0 craft
PolloCrudo
dropperStack(contador);
magma contador;
PolloAsado
$$ 2. Prueba de target (if) con hit y miss
dropperSpider("
Prueba
de
target
con
hit
y
miss
:
");
target condicion craft hit
PolloCrudo
dropperSpider("
Condición
es
verdadera
");
PolloAsado
miss
PolloCrudo
dropperSpider("
Condición
es
falsa
");
PolloAsado
$$ 3. Prueba de jukebox (switch) con disc y silence
dropperSpider("
Prueba
de
jukebox
con
disc
y
silence
:
");
jukebox opcion craft
disc 1:
PolloCrudo
dropperSpider("
Opción
1
seleccionada
");
PolloAsado
disc 2:
PolloCrudo
dropperSpider("
Opción
2
seleccionada
");
PolloAsado
silence:
PolloCrudo
dropperSpider("
Ninguna
opción
válida
seleccionada
");
PolloAsado
$$ 4. Prueba de spawner (do-while) con exhausted
dropperSpider("
Prueba
de
spawner
con
exhausted
:
");
contador = 0;
spawner
PolloCrudo
soulsand contador;
dropperStack(contador);
PolloAsado
exhausted contador >= 3;
$$ 5. Prueba de walk (for) con set, to, step
dropperSpider("
Prueba
de
walk
con
set
,
to
,
step
:
");
walk i set 0 to 10 step 2 craft
PolloCrudo
dropperStack(i);
PolloAsado
$$ 6. Prueba de wither (with)
dropperSpider("
Prueba
de
wither
:
");
coordenada@x = 10;
coordenada@y = 20;
wither coordenada craft
PolloCrudo
dropperSpider("
Coordenadas
:
(
" bind x bind "
,
" bind y bind "
)
");
PolloAsado
PolloAsado
worldSave
$*
Prueba_PR_Saltos.ne
Propósito: Verificar palabras para saltos y terminación (creeper, enderPearl, ragequit)
Fecha: 28/04/2025
*$
$$ Prueba de palabras reservadas para saltos y terminación en NotchEngine
$$ Verificando: creeper, enderPearl, ragequit
WorldName PruebaSaltos:
Inventory
$$ Variables para las pruebas
Stack contador = 0;
Stack totalPares = 0;
Stack totalImpares = 0;
Torch errorCritico = Off;
SpawnPoint
PolloCrudo
$$ 1. Prueba de creeper (break) para salir de un bucle
dropperSpider("
Prueba
de
creeper
(
break
)
:
");
walk i set 1 to 10 craft
PolloCrudo
dropperSpider("
Iteración
:
" bind i);
$$ Salimos del bucle cuando i llega a 5
target i is 5 craft hit
PolloCrudo
dropperSpider("
Encontrado
5
,
saliendo
del
bucle
con
creeper
");
creeper;
PolloAsado
PolloAsado
$$ 2. Prueba de enderPearl (continue) para saltar a la siguiente iteración
dropperSpider("
Prueba
de
enderPearl
(
continue
)
:
");
walk i set 1 to 10 craft
PolloCrudo
$$ Saltamos los números pares
target i % 2 is 0 craft hit
PolloCrudo
dropperSpider("
Número
par
" bind i bind "
,
saltando
con
enderPearl
");
enderPearl;
PolloAsado
$$ Esta parte solo se ejecuta para números impares
dropperSpider("
Procesando
número
impar
:
" bind i);
totalImpares += i;
PolloAsado
dropperSpider("
Total
de
números
impares
:
" bind totalImpares);
$$ 3. Prueba de creeper y enderPearl en bucles anidados
dropperSpider("
Prueba
de
control
de
flujo
en
bucles
anidados
:
");
walk i set 1 to 5 craft
PolloCrudo
walk j set 1 to 5 craft
PolloCrudo
$$ Saltar la iteración cuando j es 3
target j is 3 craft hit
PolloCrudo
dropperSpider("
Saltando
j
=
3
con
enderPearl
");
enderPearl;
PolloAsado
$$ Salir del bucle interno cuando j es 4
target j is 4 craft hit
PolloCrudo
dropperSpider("
Saliendo
del
bucle
interno
con
creeper
en
j
=
4
");
creeper;
PolloAsado
dropperSpider("
i
=
" bind i bind "
,
j
=
" bind j);
PolloAsado
PolloAsado
$$ 4. Prueba de ragequit (halt) para terminar el programa
$$ Nota: Esta parte debe estar comentada en pruebas reales
$$ o al final del programa, ya que detiene la ejecución
dropperSpider("
Prueba
de
ragequit
(
halt
)
:
");
target errorCritico craft hit
PolloCrudo
dropperSpider("
Error
crítico
detectado
,
terminando
programa
con
ragequit
");
$$ ragequit; $$ Comentado para evitar terminar la prueba
PolloAsado
dropperSpider("
Esta
línea
se
mostrará
si
errorCritico
es
Off
");
$$ Ejemplo descomentado pero que nunca se ejecutará
target Off craft hit
PolloCrudo
dropperSpider("
Esta
condición
nunca
se
cumple
");
ragequit;
PolloAsado
PolloAsado
worldSave
$*
Prueba_PR_Funciones.ne
Propósito: Verificar palabras para funciones y procedimientos (Spell, Ritual, respawn, ender_pearl)
Probar: Spell, Ritual, respawn, ender_pearl, crafting_table
Fecha: 28/04/2025
*$
$$ Prueba de palabras reservadas para funciones y procedimientos en NotchEngine
$$ Verificando: Spell, Ritual, respawn
WorldName PruebaFunciones:
$$ Sección de prototipos
Recipe
$$ Prototipos de funciones (Spell)
Spell sumar(Stack :: a, b) -> Stack;
Spell factorial(Stack :: n) -> Stack;
Spell esPar(Stack :: numero) -> Torch;
Spell sumarArreglo(Shelf[10] Stack :: numeros; Stack tamano) -> Stack;
$$ Prototipos de procedimientos (Ritual)
Ritual imprimirLinea(Spider :: texto);
Ritual mostrarResultado(Spider :: operacion; Stack valor);
Ritual imprimirArreglo(Shelf[10] Stack :: arr; Stack tamano);
$$ Sección de rutinas (implementación de funciones y procedimientos)
CraftingTable
$$ Funciones (Spell) con instrucción de retorno (respawn)
Spell sumar(Stack :: a, b) -> Stack
PolloCrudo
$$ Retorno con expresión simple
respawn a + b;
PolloAsado
Spell factorial(Stack :: n) -> Stack
PolloCrudo
$$ Retorno temprano con condición
target n <= 1 craft hit
PolloCrudo
respawn 1;
PolloAsado
$$ Retorno con expresión compleja y llamada recursiva
respawn n * factorial(n - 1);
PolloAsado
Spell esPar(Stack :: numero) -> Torch
PolloCrudo
target numero % 2 is 0 craft hit
PolloCrudo
respawn On;
PolloAsado
miss
PolloCrudo
respawn Off;
PolloAsado
PolloAsado
Spell sumarArreglo(Shelf[10] Stack :: numeros; Stack tamano) -> Stack
PolloCrudo
Stack suma = 0;
$$ Verificar parámetros
target tamano <= 0 craft hit
PolloCrudo
respawn 0; $$ Retorno temprano
PolloAsado
$$ Sumar elementos del arreglo
walk i set 0 to tamano - 1 craft
PolloCrudo
suma += numeros[i];
PolloAsado
respawn suma; $$ Retorno al final
PolloAsado
$$ Procedimientos (Ritual) con posibles retornos vacíos
Ritual imprimirLinea(Spider :: texto)
PolloCrudo
dropperSpider(texto);
dropperSpider("
--
--
--
--
--
--
--
--
--
--
--
--
");
PolloAsado
Ritual mostrarResultado(Spider :: operacion; Stack valor)
PolloCrudo
dropperSpider(operacion bind "
:
" bind valor);
$$ Retorno temprano sin valor
target valor < 0 craft hit
PolloCrudo
dropperSpider("
Valor
negativo
");
respawn; $$ Retorno vacío temprano
PolloAsado
dropperSpider("
Valor
válido
procesado
");
PolloAsado
Ritual imprimirArreglo(Shelf[10] Stack :: arr; Stack tamano)
PolloCrudo
target tamano <= 0 craft hit
PolloCrudo
dropperSpider("
Arreglo
vacío
");
respawn; $$ Retorno vacío temprano
PolloAsado
dropperSpider("
Elementos
del
arreglo
:
");
walk i set 0 to tamano - 1 craft
PolloCrudo
dropperStack(arr[i]);
PolloAsado
PolloAsado
$$ Punto de entrada con llamadas a funciones y procedimientos
SpawnPoint
PolloCrudo
$$ Declaración de variables
Stack a = 5;
Stack b = 7;
Stack resultado;
Shelf[10] Stack numeros;
$$ Inicializar arreglo
walk i set 0 to 9 craft
PolloCrudo
numeros[i] = i + 1;
PolloAsado
$$ Llamadas a funciones (invocación directa)
resultado = sumar(a, b);
dropperSpider("
Suma
:
" bind resultado);
resultado = factorial(5);
dropperSpider("
Factorial
de
5
:
" bind resultado);
Torch esPar5 = esPar(5);
dropperSpider("
Es
5
par
:
");
dropperTorch(esPar5);
resultado = sumarArreglo(numeros, 10);
dropperSpider("
Suma
del
arreglo
:
" bind resultado);
$$ Llamadas a procedimientos
imprimirLinea("
==
==
Resultados
de
pruebas
==
==
");
mostrarResultado("
Suma
de
5
y
7
", sumar(a, b));
mostrarResultado("
Valor
negativo
", -10);
imprimirArreglo(numeros, 5);
imprimirArreglo(numeros, 0);
PolloAsado
worldSave
$*
Prueba_PR_Operadores.ne
Propósito: Verificar operadores textuales reales en Notch Engine
Probar: soulsand, magma, and, or, not, xor, bind, #, from ##, except ##, seek,
add, drop, feed, map, biom, void, isEngraved, isInscribed, etchUp, etchDown,
unlock, lock, make, gather, forge, expand
Fecha: 28/04/2025
*$
WorldName PruebaOperadores:
Inventory {
Stack contador = 5; $$ Inicializa contador con 5
Torch condicion1 = On; $$ Condición 1 es verdadera
Torch condicion2 = Off; $$ Condición 2 es falsa
Torch resultado; $$ Variable para almacenar resultados booleanos
Spider texto1 = "
Notch
"; $$ Texto inicial "
Notch
"
Spider texto2 = "
Engine
"; $$ Texto inicial "
Engine
"
Spider textoCompleto; $$ Variable para texto combinado
Rune letra = 'a'; $$ Letra inicial 'a'
Rune letraMayuscula; $$ Variable para letra mayúscula
Chest conjunto1 = {: 1, 2, 3 :}; $$ Conjunto inicial con 1, 2, 3
Chest conjunto2 = {: 3, 4, 5 :}; $$ Conjunto inicial con 3, 4, 5
Chest conjuntoResultado; $$ Variable para resultado de conjuntos
Book archivo1 = {/ "
datos
.
txt
", 'E' /}; $$ Archivo para escritura "
datos
.
txt
"
Book archivo2 = {/ "
resultado
.
txt
", 'E' /}; $$ Archivo para escritura "
resultado
.
txt
"
Ghast flotante1 = 3.5; $$ Flotante inicial 3.5
Ghast flotante2 = 2.5; $$ Flotante inicial 2.5
Ghast resultadoFlotante; $$ Variable para resultado de operaciones flotantes
}
SpawnPoint {
PolloCrudo
$$ soulsand y magma
soulsand contador; $$ Aplica soulsand a contador
magma contador; $$ Aplica magma a contador
$$ and, or, not, xor
resultado = condicion1 and condicion2; $$ Resultado es verdadero si ambas condiciones son verdaderas
resultado = condicion1 or condicion2; $$ Resultado es verdadero si al menos una condición es verdadera
resultado = not condicion1; $$ Resultado es el opuesto de condicion1
resultado = condicion1 xor condicion2; $$ Resultado es verdadero si solo una condición es verdadera
$$ bind, #, from ##, except ##, seek
textoCompleto = bind(texto1, "
" bind texto2); $$ Combina texto1 y texto2 con un espacio
Stack longitud = #(textoCompleto); $$ Longitud de textoCompleto
Spider subcadena = from textoCompleto ## 0 ## 5; $$ Subcadena de textoCompleto desde 0 hasta 5
Spider sinNotch = except textoCompleto ## 0 ## 6; $$ Elimina caracteres de 0 a 6 en textoCompleto
Stack posicion = seek(textoCompleto, "
Engine
"); $$ Posición de "
Engine
" en textoCompleto
$$ isEngraved, isInscribed, etchUp, etchDown
Torch esLetra = isEngraved(letra); $$ Verifica si letra es una letra
Torch esDigito = isInscribed(letra); $$ Verifica si letra es un dígito
letraMayuscula = etchUp(letra); $$ Convierte letra a mayúscula
Rune letraMinuscula = etchDown(letraMayuscula); $$ Convierte letraMayuscula a minúscula
$$ Operaciones de conjuntos
add(conjunto1, 4); $$ Añade 4 a conjunto1
drop(conjunto1, 2); $$ Elimina 2 de conjunto1
conjuntoResultado = feed(conjunto1, conjunto2); $$ Intersección de conjunto1 y conjunto2
resultado = map(conjunto1, 3); $$ Verifica si 3 está en conjunto1
Torch conjuntoVacio = void(conjunto1); $$ Verifica si conjunto1 está vacío
$$ Operaciones de archivos
unlock(archivo1); $$ Abre archivo1 para escritura
forge(archivo1, "
Texto
de
prueba
"); $$ Escribe "
Texto
de
prueba
" en archivo1
lock(archivo1); $$ Cierra archivo1
Book nuevoArchivo = make({/ "
nuevo
.
txt
", 'E' /}); $$ Crea nuevo archivo "
nuevo
.
txt
"
forge(nuevoArchivo, "
Contenido
del
nuevo
archivo
"); $$ Escribe en nuevoArchivo
lock(nuevoArchivo); $$ Cierra nuevoArchivo
unlock(archivo1); $$ Abre archivo1
unlock(nuevoArchivo); $$ Abre nuevoArchivo
expand(archivo1, nuevoArchivo); $$ Expande archivo1 con contenido de nuevoArchivo
lock(archivo1); $$ Cierra archivo1
lock(nuevoArchivo); $$ Cierra nuevoArchivo
$$ Operadores de flotantes
resultadoFlotante = flotante1 :+ flotante2; $$ Suma de flotante1 y flotante2
resultadoFlotante = flotante1 :- flotante2; $$ Resta de flotante1 y flotante2
resultadoFlotante = flotante1 :* flotante2; $$ Multiplicación de flotante1 y flotante2
resultadoFlotante = flotante1 :// flotante2; $$ División de flotante1 y flotante2
resultadoFlotante = flotante1 :% flotante2; $$ Módulo de flotante1 y flotante2
PolloAsado
}
worldSave
$*
Prueba_Lit_Enteros.ne
Propósito: Verificar reconocimiento de literales enteros (positivos, negativos, cero)
Probar: Stack
Fecha: 28/04/2025
*$
$$ Prueba de literales enteros en NotchEngine
$$ Verificando: enteros positivos, negativos y cero
WorldName PruebaLitEnteros:
Bedrock
$$ Constantes enteras
Obsidian Stack CERO 0;
Obsidian Stack POSITIVO 42;
Obsidian Stack NEGATIVO -42;
Obsidian Stack MAX_VALOR 2147483647; $$ Valor máximo de 32 bits
Obsidian Stack MIN_VALOR -2147483648; $$ Valor mínimo de 32 bits
Inventory
$$ Variables con literales enteros
Stack cero = 0;
Stack uno = 1;
Stack diez = 10;
Stack cien = 100;
Stack mil = 1000;
Stack millon = 1000000;
$$ Enteros negativos
Stack negUno = -1;
Stack negDiez = -10;
Stack negCien = -100;
Stack negMil = -1000;
Stack negMillon = -1000000;
$$ Valor entero máximo y mínimo (aproximadamente)
Stack maxInt = 2147483647;
Stack minInt = -2147483648;
$$ Variables para resultados
Stack resultado = 0;
SpawnPoint
PolloCrudo
$$ Operaciones aritméticas con literales enteros directos
resultado = 5 + 3; $$ 8
dropperSpider("
5
+
3
=
" bind resultado);
resultado = 10 - 7; $$ 3
dropperSpider("
10
-
7
=
" bind resultado);
resultado = 6 * 4; $$ 24
dropperSpider("
6
*
4
=
" bind resultado);
resultado = 20 // 4; $$ 5
dropperSpider("
20
4
=
" bind resultado);
resultado = 17 % 5; $$ 2
dropperSpider("
17
%
5
=
" bind resultado);
$$ Uso de literales enteros en expresiones complejas
resultado = (5 + 3) * 2 - 4 // 2; $$ 16 - 2 = 14
dropperSpider("
(
5
+
3
)
*
2
-
4
2
=
" bind resultado);
$$ Operaciones con literales enteros negativos
resultado = -5 + 10; $$ 5
dropperSpider("
-
5
+
10
=
" bind resultado);
resultado = 5 + -10; $$ -5
dropperSpider("
5
+
-
10
=
" bind resultado);
resultado = -5 * -4; $$ 20
dropperSpider("
-
5
*
-
4
=
" bind resultado);
$$ Uso de literales enteros en estructuras de control
walk i set 1 to 5 craft
PolloCrudo
dropperSpider("
Iteración
:
" bind i);
PolloAsado
$$ Comparaciones con literales enteros
target 10 > 5 craft hit
PolloCrudo
dropperSpider("
10
es
mayor
que
5
");
PolloAsado
target 0 is 0 craft hit
PolloCrudo
dropperSpider("
0
es
igual
a
0
");
PolloAsado
target -10 < -5 craft hit
PolloCrudo
dropperSpider("
-
10
es
menor
que
-
5
");
PolloAsado
$$ Operaciones con valores extremos (cuidado con overflow)
dropperSpider("
Valor
máximo
de
entero
:
" bind maxInt);
dropperSpider("
Valor
mínimo
de
entero
:
" bind minInt);
$$ Verificación del cero
target 0 is cero craft hit
PolloCrudo
dropperSpider("
Ambas
representaciones
de
cero
son
iguales
");
PolloAsado
PolloAsado
worldSave
$*
Prueba_Lit_Flotantes.ne
Propósito: Verificar reconocimiento de números flotantes (con parte decimal, sin parte decimal, negativos)
Probar: Ghast
Fecha: 28/04/2025
*$
$$ Prueba de literales flotantes en NotchEngine
$$ Verificando: flotantes con parte decimal, sin parte decimal, y negativos
WorldName PruebaLitFlotantes:
Bedrock
$$ Constantes flotantes
Obsidian Ghast CERO_PUNTO_CERO 0.0;
Obsidian Ghast PI 3.14159;
Obsidian Ghast E 2.71828;
Obsidian Ghast NEG_PI -3.14159;
Obsidian Ghast GRAVEDAD -9.8;
Inventory
$$ Flotantes positivos con parte decimal
Ghast decimal1 = 0.5;
Ghast decimal2 = 1.25;
Ghast decimal3 = 3.14159;
Ghast decimal4 = 2.71828;
Ghast decimal5 = 123.456;
$$ Flotantes negativos con parte decimal
Ghast negDecimal1 = -0.5;
Ghast negDecimal2 = -1.25;
Ghast negDecimal3 = -3.14159;
Ghast negDecimal4 = -2.71828;
Ghast negDecimal5 = -123.456;
$$ Formas alternativas (punto al principio, sin parte decimal)
Ghast decimal6 = .5; $$ Sin cero al principio, comienza con punto
Ghast decimal7 = 5.; $$ Sin decimales, termina con punto
$$ Números con muchos decimales
Ghast precisionAlta = 1.123456789012345;
$$ Números muy pequeños y muy grandes
Ghast muyPequeno = 0.0000001;
Ghast muyGrande = 1000000.0;
$$ Variables para resultados
Ghast resultado = 0.0;
SpawnPoint
PolloCrudo
$$ Operaciones aritméticas con literales flotantes directos
resultado = 5.5 :+ 3.5; $$ 9.0
dropperSpider("
5.5
:
+
3.5
=
");
dropperGhast(resultado);
resultado = 10.75 :- 7.25; $$ 3.5
dropperSpider("
10.75
:
-
7.25
=
");
dropperGhast(resultado);
resultado = 6.5 :* 2.0; $$ 13.0
dropperSpider("
6.5
:
*
2.0
=
");
dropperGhast(resultado);
resultado = 20.0 :// 4.0; $$ 5.0
dropperSpider("
20.0
:
4.0
=
");
dropperGhast(resultado);
resultado = 7.5 :% 2.0; $$ 1.5
dropperSpider("
7.5
:
%
2.0
=
");
dropperGhast(resultado);
$$ Uso de notaciones decimales alternativas
resultado = .5 :+ 2.; $$ 0.5 + 2.0 = 2.5
dropperSpider("
.
5
:
+
2
.
=
");
dropperGhast(resultado);
$$ Operaciones con literales flotantes negativos
resultado = -5.5 :+ 10.0; $$ 4.5
dropperSpider("
-
5.5
:
+
10.0
=
");
dropperGhast(resultado);
resultado = 5.0 :+ -10.0; $$ -5.0
dropperSpider("
5.0
:
+
-
10.0
=
");
dropperGhast(resultado);
resultado = -5.0 :* -4.0; $$ 20.0
dropperSpider("
-
5.0
:
*
-
4.0
=
");
dropperGhast(resultado);
$$ Expresiones complejas con flotantes
resultado = (2.5 :+ 1.5) :* 3.0 :- 5.0 :// 2.0; $$ 12.0 - 2.5 = 9.5
dropperSpider("
(
2.5
:
+
1.5
)
:
*
3.0
:
-
5.0
:
2.0
=
");
dropperGhast(resultado);
$$ Comparaciones con flotantes
target 3.14 > 3.0 craft hit
PolloCrudo
dropperSpider("
3.14
es
mayor
que
3.0
");
PolloAsado
target 0.1 :+ 0.2 isNot 0.3 craft hit $$ Debido a errores de precisión en flotantes
PolloCrudo
dropperSpider("
0.1
+
0.2
no
es
exactamente
igual
a
0.3
(
error
de
precisión
)
");
dropperGhast(0.1 :+ 0.2);
PolloAsado
$$ Conversión y coherción de tipos
Stack entero = 3.14159 >> Stack; $$ Cohersión a entero (trunca a 3)
dropperSpider("
PI
truncado
a
entero
:
" bind entero);
$$ Mostrar valores con diferentes precisiones
dropperSpider("
Valor
de
PI
:
");
dropperGhast(PI);
dropperSpider("
Número
con
alta
precisión
:
");
dropperGhast(precisionAlta);
dropperSpider("
Número
muy
pequeño
:
");
dropperGhast(muyPequeno);
dropperSpider("
Número
muy
grande
:
");
dropperGhast(muyGrande);
PolloAsado
worldSave
$*
Prueba_Lit_Caracteres.ne
Propósito: Verificar reconocimiento de caracteres (letras, dígitos, símbolos, escapes)
Probar: Rune, dropperRune, dropperSpider, dropperTorch
Fecha: 28/04/2025
*$
$$ Prueba de literales de caracteres en NotchEngine
$$ Verificando: letras, dígitos, símbolos y secuencias de escape
WorldName PruebaLitCaracteres:
Bedrock
$$ Constantes de caracteres
Obsidian Rune LETRA_A 'A';
Obsidian Rune LETRA_Z 'Z';
Obsidian Rune DIGITO_0 '0';
Obsidian Rune DIGITO_9 '9';
Obsidian Rune NUEVA_LINEA '\n';
Obsidian Rune TABULACION '\t';
Inventory
$$ Letras mayúsculas
Rune letraA = 'A';
Rune letraB = 'B';
Rune letraC = 'C';
Rune letraZ = 'Z';
$$ Letras minúsculas
Rune letraMina = 'a';
Rune letraMinb = 'b';
Rune letraMinc = 'c';
Rune letraMinz = 'z';
$$ Dígitos
Rune digito0 = '0';
Rune digito1 = '1';
Rune digito5 = '5';
Rune digito9 = '9';
$$ Símbolos comunes
Rune simboloExclamacion = '!';
Rune simboloInterrogacion = '?';
Rune simboloArroba = '@';
Rune simboloNumeral = '#';
Rune simboloDolar = '$';
Rune simboloPorcentaje = '%';
Rune simboloAmpersand = '&';
Rune simboloAsterisco = '*';
Rune simboloParentesisIzq = '(';
Rune simboloParentesisDer = ')';
Rune simboloGuion = '-';
Rune simboloGuionBajo = '_';
Rune simboloIgual = '=';
Rune simboloMas = '+';
Rune simboloCorcheteIzq = '[';
Rune simboloCorcheteDer = ']';
Rune simboloLlaveIzq = '{';
Rune simboloLlaveDer = '}';
Rune simboloPuntoyComa = ';';
Rune simboloDosPuntos = ':';
Rune simboloComillaSimple = '\'';
Rune simboloComillaDoble = '"
';
Rune simboloBarra = '
';
Rune simboloBarraInversa = '
';
Rune simboloBarraVertical = '
';
Rune simboloComa = '
,
';
Rune simboloPunto = '
.
';
Rune simboloMenorQue = '
<
';
Rune simboloMayorQue = '
>
';
$$ Secuencias de escape
Rune escapeNuevaLinea = '
n
';
Rune escapeTabulacion = '
t
';
Rune escapeRetornoCarro = '
r
';
Rune escapeBarraInversa = '
';
Rune escapeComillaSimple = '
''
;
Rune
escapeComillaDoble
=
'\"'
;
SpawnPoint
PolloCrudo
dropperSpider
(
"Letras mayúsculas: "
)
;
dropperRune
(
letraA
)
;
dropperRune
(
letraB
)
;
dropperRune
(
letraC
)
;
dropperSpider
(
"Letras minúsculas: "
)
;
dropperRune
(
letraMina
)
;
dropperRune
(
letraMinb
)
;
dropperRune
(
letraMinc
)
;
dropperSpider
(
"Dígitos: "
)
;
dropperRune
(
digito0
)
;
dropperRune
(
digito1
)
;
dropperRune
(
digito5
)
;
dropperRune
(
digito9
)
;
dropperSpider
(
"Símbolos: "
)
;
dropperRune
(
simboloExclamacion
)
;
dropperRune
(
simboloInterrogacion
)
;
dropperRune
(
simboloArroba
)
;
dropperRune
(
simboloNumeral
)
;
Spider
texto
=
"NotchEngine"
;
Rune
primerCaracter
=
texto
[
0
]
;
Rune
ultimoCaracter
=
texto
[
10
]
;
dropperSpider
(
"Primer carácter de 'NotchEngine': "
)
;
dropperRune
(
primerCaracter
)
;
dropperSpider
(
"Último carácter de 'NotchEngine': "
)
;
dropperRune
(
ultimoCaracter
)
;
Rune
letraMinuscula
=
'a'
;
Rune
letraMayuscula
=
etchUp
(
letraMinuscula
)
;
dropperSpider
(
"Minúscula: "
)
;
dropperRune
(
letraMinuscula
)
;
dropperSpider
(
"Convertida a mayúscula: "
)
;
dropperRune
(
letraMayuscula
)
;
letraMinuscula
=
etchDown
(
letraMayuscula
)
;
dropperSpider
(
"Convertida nuevamente a minúscula: "
)
;
dropperRune
(
letraMinuscula
)
;
Torch
esLetra
=
isEngraved
(
'A'
)
;
Torch
esDigito
=
isInscribed
(
'5'
)
;
dropperSpider
(
"¿'A' es una letra? "
)
;
dropperTorch
(
esLetra
)
;
dropperSpider
(
"¿'5' es un dígito? "
)
;
dropperTorch
(
esDigito
)
;
esLetra
=
isEngraved
(
'7'
)
;
esDigito
=
isInscribed
(
'K'
)
;
dropperSpider
(
"¿'7' es una letra? "
)
;
dropperTorch
(
esLetra
)
;
dropperSpider
(
"¿'K' es un dígito? "
)
;
dropperTorch
(
esDigito
)
;
Stack
valorAsciiA
=
letraA
>
>
Stack
;
dropperSpider
(
"Valor ASCII de 'A': "
bind
valorAsciiA
)
;
PolloAsado
worldSave
WorldName
PruebaLitStrings
:
Bedrock
Obsidian
Spider
VACIO
""
;
Obsidian
Spider
ESPACIO
" "
;
Obsidian
Spider
SALUDO
"Hola Mundo"
;
Obsidian
Spider
CON_COMILLAS
"Este string tiene \"comillas\""
;
Obsidian
Spider
MULTILINEA
"Primera línea\nSegunda línea"
;
Inventory
Spider
cadenaVacia
=
""
;
Spider
espacioSimple
=
" "
;
Spider
cadenaSimple
=
"Texto simple"
;
Spider
conNumeros
=
"Notch Engine v1.0"
;
Spider
conSimbolos
=
"¡Hola, mundo! ¿Cómo estás?"
;
Spider
conCaracteresEspeciales
=
"#$%&/()=?¡"
;
Spider
conNuevaLinea
=
"Primera línea\nSegunda línea"
;
Spider
conTabulacion
=
"Columna1\tColumna2\tColumna3"
;
Spider
conRetornoCarro
=
"Texto con\rretorno de carro"
;
Spider
conBarraInversa
=
"Ruta de archivo: C:\\Archivos\\datos.txt"
;
Spider
conComillasSimples
=
"Texto con 'comillas simples'"
;
Spider
conComillasDobles
=
"Texto con \"comillas dobles\""
;
Spider
mixto
=
"Abc123!@#\n\t\"'"
;
Spider
cadenaLarga
=
"Esta es una cadena de texto más larga que contiene múltiples palabras, números como 12345, y símbolos como $%&. Es útil para probar el manejo de cadenas extensas en el analizador léxico y asegurarse de que no hay limitaciones inesperadas en la longitud de las cadenas."
;
Spider
prefijo
=
"Notch"
;
Spider
sufijo
=
"Engine"
;
Spider
resultado
;
SpawnPoint
PolloCrudo
dropperSpider
(
"Cadena simple: "
bind
cadenaSimple
)
;
dropperSpider
(
"Cadena con números: "
bind
conNumeros
)
;
dropperSpider
(
"Cadena con símbolos: "
bind
conSimbolos
)
;
resultado
=
bind
(
prefijo
,
" "
bind
sufijo
)
;
dropperSpider
(
"Concatenación: "
bind
resultado
)
;
Stack
longitud
=
#
(
resultado
)
;
dropperSpider
(
"Longitud de '"
bind
resultado
bind
"': "
bind
longitud
)
;
Spider
subcadena
=
from
resultado
#
#
0
#
#
5
;
dropperSpider
(
"Subcadena (0, 5): "
bind
subcadena
)
;
Spider
sinNotch
=
except
resultado
#
#
0
#
#
6
;
dropperSpider
(
"Sin los primeros 6 caracteres: "
bind
sinNotch
)
;
Stack
posicion
=
seek
(
resultado
,
"Engine"
)
;
dropperSpider
(
"Posición de 'Engine': "
bind
posicion
)
;
Rune
primerCaracter
=
resultado
[
0
]
;
dropperSpider
(
"Primer carácter: "
)
;
dropperRune
(
primerCaracter
)
;
Rune
ultimoCaracter
=
resultado
[
11
]
;
dropperSpider
(
"Último carácter: "
)
;
dropperRune
(
ultimoCaracter
)
;
dropperSpider
(
"Cadena con nueva línea:"
)
;
dropperSpider
(
conNuevaLinea
)
;
dropperSpider
(
"Cadena con tabulaciones:"
)
;
dropperSpider
(
conTabulacion
)
;
dropperSpider
(
"Cadena con comillas dobles:"
)
;
dropperSpider
(
conComillasDobles
)
;
dropperSpider
(
"Cadena larga:"
)
;
dropperSpider
(
cadenaLarga
)
;
target
cadenaVacia
is
""
craft
hit
PolloCrudo
dropperSpider
(
"La cadena está vacía"
)
;
PolloAsado
target
SALUDO
is
"Hola Mundo"
craft
hit
PolloCrudo
dropperSpider
(
"Las cadenas son iguales"
)
;
PolloAsado
PolloAsado
worldSave
WorldName
PruebaLitArreglos
:
Bedrock
Inventory
Shelf
[
5
]
Stack
numerosSimples
=
[
1
,
2
,
3
,
4
,
5
]
;
Shelf
[
3
]
Stack
numerosNegativos
=
[
-
10
,
-
20
,
-
30
]
;
Shelf
[
4
]
Stack
numerosMixtos
=
[
-
2
,
0
,
2
,
4
]
;
Shelf
[
1
]
Stack
unicoElemento
=
[
42
]
;
Shelf
[
0
]
Stack
arregloVacio
=
[
]
;
Shelf
[
5
]
Rune
vocales
=
[
'a'
,
'e'
,
'i'
,
'o'
,
'u'
]
;
Shelf
[
5
]
Rune
simbolos
=
[
'!'
,
'@'
,
'#'
,
'$'
,
'%'
]
;
Shelf
[
3
]
Spider
nombres
=
[
"Steve"
,
"Alex"
,
"Herobrine"
]
;
Shelf
[
4
]
Spider
diasSemana
=
[
"Lunes"
,
"Martes"
,
"Miércoles"
,
"Jueves"
]
;
Shelf
[
4
]
Torch
flags
=
[
On
,
Off
,
On
,
On
]
;
Shelf
[
3
]
Ghast
decimales
=
[
3.14
,
2.71
,
1.618
]
;
Shelf
[
3
]
Shelf
[
3
]
Stack
matriz
=
[
[
1
,
2
,
3
]
,
[
4
,
5
,
6
]
,
[
7
,
8
,
9
]
]
;
Shelf
[
2
]
Shelf
[
2
]
Shelf
[
2
]
Stack
cubo
=
[
[
[
1
,
2
]
,
[
3
,
4
]
]
,
[
[
5
,
6
]
,
[
7
,
8
]
]
]
;
Stack
suma
=
0
;
Stack
elementoActual
=
0
;
SpawnPoint
PolloCrudo
elementoActual
=
numerosSimples
[
0
]
;
dropperSpider
(
"Primer elemento del arreglo: "
bind
elementoActual
)
;
elementoActual
=
numerosSimples
[
4
]
;
dropperSpider
(
"Último elemento del arreglo: "
bind
elementoActual
)
;
numerosSimples
[
2
]
=
30
;
dropperSpider
(
"Elemento modificado: "
bind
numerosSimples
[
2
]
)
;
suma
=
0
;
walk
i
set
0
to
4
craft
PolloCrudo
suma
+
=
numerosSimples
[
i
]
;
dropperSpider
(
"Elemento "
bind
i
bind
": "
bind
numerosSimples
[
i
]
)
;
PolloAsado
dropperSpider
(
"Suma de todos los elementos: "
bind
suma
)
;
dropperSpider
(
"Vocales: "
)
;
walk
i
set
0
to
4
craft
PolloCrudo
dropperRune
(
vocales
[
i
]
)
;
PolloAsado
dropperSpider
(
"Nombres: "
)
;
walk
i
set
0
to
2
craft
PolloCrudo
dropperSpider
(
nombres
[
i
]
)
;
PolloAsado
dropperSpider
(
"Flags: "
)
;
walk
i
set
0
to
3
craft
PolloCrudo
dropperTorch
(
flags
[
i
]
)
;
PolloAsado
dropperSpider
(
"Decimales: "
)
;
walk
i
set
0
to
2
craft
PolloCrudo
dropperGhast
(
decimales
[
i
]
)
;
PolloAsado
elementoActual
=
matriz
[
1
]
[
1
]
;
dropperSpider
(
"Elemento central de la matriz: "
bind
elementoActual
)
;
matriz
[
0
]
[
2
]
=
10
;
dropperSpider
(
"Elemento modificado de la matriz: "
bind
matriz
[
0
]
[
2
]
)
;
dropperSpider
(
"Matriz completa:"
)
;
walk
i
set
0
to
2
craft
PolloCrudo
walk
j
set
0
to
2
craft
PolloCrudo
dropperStack
(
matriz
[
i
]
[
j
]
)
;
PolloAsado
dropperSpider
(
""
)
;
PolloAsado
elementoActual
=
cubo
[
1
]
[
0
]
[
1
]
;
dropperSpider
(
"Elemento de cubo [1][0][1]: "
bind
elementoActual
)
;
Shelf
[
4
]
Stack
fibonacci
=
[
1
,
1
,
2
,
3
]
;
dropperSpider
(
"Fibonacci: "
)
;
walk
i
set
0
to
3
craft
PolloCrudo
dropperStack
(
fibonacci
[
i
]
)
;
PolloAsado
PolloAsado
worldSave
WorldName
PruebaLitRegistros
:
Inventory
Entity
Jugador
PolloCrudo
Spider
nombre
;
Stack
nivel
;
Ghast
salud
;
Torch
activo
;
PolloAsado
;
Entity
Coordenada
PolloCrudo
Stack
x
;
Stack
y
;
Stack
z
;
PolloAsado
;
Entity
Configuracion
PolloCrudo
Torch
modoDebug
;
Stack
volumen
;
Spider
idioma
;
PolloAsado
;
Entity
Jugador
steve
=
{
nombre
:
"Steve"
,
nivel
:
1
,
salud
:
20.0
,
activo
:
On
}
;
Entity
Jugador
alex
=
{
nombre
:
"Alex"
,
nivel
:
2
,
salud
:
18.5
,
activo
:
On
}
;
Entity
Coordenada
posicion
=
{
x
:
10
,
y
:
20
,
z
:
30
}
;
Entity
Configuracion
config
=
{
modoDebug
:
Off
,
volumen
:
75
,
idioma
:
"Español"
}
;
Entity
Jugador
jugadorVacio
=
{
}
;
Entity
Coordenada
origen
=
{
x
:
0
}
;
Entity
Coordenada
punto
=
{
x
:
5
+
5
,
y
:
10
*
2
,
z
:
100
2
}
;
SpawnPoint
PolloCrudo
dropperSpider
(
steve
@
nombre
)
;
dropperStack
(
posicion
@
x
)
;
dropperTorch
(
config
@
modoDebug
)
;
steve
@
nivel
=
5
;
posicion
@
z
=
50
;
Stack
nivelTotal
=
steve
@
nivel
+
alex
@
nivel
;
dropperStack
(
nivelTotal
)
;
wither
steve
craft
PolloCrudo
dropperSpider
(
"Nombre: "
bind
nombre
)
;
dropperStack
(
nivel
)
;
dropperGhast
(
salud
)
;
PolloAsado
Entity
Jugador
herobrine
=
{
nombre
:
"Herobrine"
,
nivel
:
100
,
salud
:
1000.0
,
activo
:
On
}
;
Entity
Coordenada
pos2
=
{
x
:
100
,
y
:
200
,
z
:
300
}
;
PolloAsado
worldSave
WorldName
PruebaLitConjuntos
:
Inventory
Chest
numeros
=
{
:
1
,
2
,
3
,
4
,
5
:
}
;
Chest
primos
=
{
:
2
,
3
,
5
,
7
,
11
,
13
,
17
,
19
:
}
;
Chest
pares
=
{
:
2
,
4
,
6
,
8
,
10
:
}
;
Chest
vocales
=
{
:
'a'
,
'e'
,
'i'
,
'o'
,
'u'
:
}
;
Chest
consonantes
=
{
:
'b'
,
'c'
,
'd'
,
'f'
,
'g'
:
}
;
Chest
nombres
=
{
:
"Steve"
,
"Alex"
,
"Herobrine"
,
"Notch"
:
}
;
Chest
herramientas
=
{
:
"Espada"
,
"Pico"
,
"Hacha"
,
"Pala"
:
}
;
Chest
vacio
=
{
:
:
}
;
Chest
singleton
=
{
:
42
:
}
;
Chest
mezcla
=
{
:
1
,
'a'
,
"texto"
:
}
;
Chest
calculados
=
{
:
1
+
1
,
2
*
2
,
10
2
:
}
;
Chest
booleanos
=
{
:
On
,
Off
:
}
;
SpawnPoint
PolloCrudo
add
(
numeros
,
6
)
;
dropperSpider
(
"Después de add(numeros, 6):"
)
;
drop
(
primos
,
2
)
;
dropperSpider
(
"Después de drop(primos, 2):"
)
;
Chest
union
=
feed
(
numeros
,
primos
)
;
dropperSpider
(
"Unión de numeros y primos:"
)
;
Chest
interseccion
=
map
(
numeros
,
pares
)
;
dropperSpider
(
"Intersección de numeros y pares:"
)
;
Torch
contiene
=
biom
(
vocales
,
'a'
)
;
dropperTorch
(
contiene
)
;
Torch
esVacio
=
void
(
vacio
)
;
dropperTorch
(
esVacio
)
;
Chest
conEspacios
=
{
:
'a'
,
'b'
,
'c'
:
}
;
Chest
conComentarios
=
{
:
1
,
2
,
3
:
}
;
Chest
{
:
1
,
'x'
,
"y"
:
}
;
PolloAsado
worldSave
WorldName
PruebaLitArchivos
:
Inventory
Book
archivoConfiguracion
=
{
"config.txt"
,
'L'
}
;
Book
archivoJugadores
=
{
"jugadores.dat"
,
'L'
}
;
Book
archivoNiveles
=
{
"niveles/nivel1.map"
,
'L'
}
;
Book
archivoLog
=
{
"sistema.log"
,
'E'
}
;
Book
archivoResultados
=
{
"resultados.txt"
,
'E'
}
;
Book
archivoExportacion
=
{
"export/datos.csv"
,
'E'
}
;
Book
archivoPuntajes
=
{
"puntajes.dat"
,
'A'
}
;
Book
archivoInventario
=
{
"inventario.sav"
,
'A'
}
;
Book
archivoEspecial
=
{
"archivo con espacios.txt"
,
'L'
}
;
Book
archivoEspecial2
=
{
"datos_especiales-2023.dat"
,
'E'
}
;
Book
archivoRutaRelativa
=
{
"../datos/config.ini"
,
'L'
}
;
Book
archivoRutaAbsoluta
=
{
"C:/Notch/Engine/data.bin"
,
'E'
}
;
Book
archivoTexto
=
{
"readme.txt"
,
'L'
}
;
Book
archivoImagen
=
{
"textura.png"
,
'L'
}
;
Book
archivoJSON
=
{
"settings.json"
,
'A'
}
;
Book
archivoXML
=
{
"estructura.xml"
,
'A'
}
;
Book
conBarras
=
{
"dir/subdir/archivo.ext"
,
'L'
}
;
Book
conPuntos
=
{
"../../archivo.ext"
,
'E'
}
;
Book
espaciado1
=
{
"compacto.txt"
,
'L'
}
;
Book
espaciado2
=
{
"espacios.txt"
,
'E'
}
;
Book
comentado
=
{
"log.txt"
,
'L'
}
;
SpawnPoint
PolloCrudo
unlock
(
archivoLog
)
;
forge
(
archivoLog
,
"Entrada de log: Inicio de programa"
)
;
lock
(
archivoLog
)
;
Book
nuevoArchivo
=
make
(
{
"nuevo.txt"
,
'E'
}
)
;
unlock
(
archivoConfiguracion
)
;
Spider
contenido
=
gather
(
archivoConfiguracion
)
;
lock
(
archivoConfiguracion
)
;
expand
(
archivoLog
,
archivoResultados
)
;
Book
{
"sinVariable.txt"
,
'A'
}
;
Book
arch1
=
{
"uno.txt"
,
'L'
}
;
Book
arch2
=
{
"dos.txt"
,
'E'
}
;
Book
conComentarioMedio
=
{
"comentado.txt"
,
'A'
}
;
PolloAsado
worldSave
WorldName
PruebaOpAritmeticos
:
Inventory
Stack
a
=
10
;
Stack
b
=
3
;
Stack
c
;
Stack
resultado
;
SpawnPoint
PolloCrudo
c
=
a
+
b
;
dropperSpider
(
"Suma: "
bind
c
)
;
c
=
a
-
b
;
dropperSpider
(
"Resta: "
bind
c
)
;
c
=
a
*
b
;
dropperSpider
(
"Multiplicación: "
bind
c
)
;
c
=
a
b
;
dropperSpider
(
"División entera: "
bind
c
)
;
c
=
a
%
b
;
dropperSpider
(
"Módulo: "
bind
c
)
;
resultado
=
a
+
b
*
c
;
dropperSpider
(
"a + b * c = "
bind
resultado
)
;
resultado
=
(
a
+
b
)
*
c
;
dropperSpider
(
"(a + b) * c = "
bind
resultado
)
;
resultado
=
a
+
b
+
c
;
dropperSpider
(
"a + b + c = "
bind
resultado
)
;
resultado
=
a
*
b
c
+
a
-
b
;
dropperSpider
(
"a * b // c + a - b = "
bind
resultado
)
;
resultado
=
-
a
;
dropperSpider
(
"-a = "
bind
resultado
)
;
resultado
=
5
+
3
;
dropperSpider
(
"5 + 3 = "
bind
resultado
)
;
resultado
=
-
(
a
+
b
)
;
dropperSpider
(
"-(a + b) = "
bind
resultado
)
;
resultado
=
a
+
b
;
resultado
=
a
-
b
;
resultado
=
a
*
b
;
resultado
=
a
b
;
resultado
=
a
%
b
;
resultado
=
a
+
b
;
resultado
=
a
-
b
;
resultado
=
a
*
b
;
resultado
=
a
b
;
resultado
=
a
%
b
;
resultado
=
a
+
b
;
resultado
=
a
*
b
;
resultado
=
(
(
(
(
a
+
b
)
*
c
)
2
)
%
10
)
;
soulsand
a
;
resultado
=
a
+
b
;
magma
b
;
resultado
=
a
-
b
;
PolloAsado
worldSave
WorldName
PruebaOpFlotantes
:
Inventory
Ghast
x
=
10.5
;
Ghast
y
=
3.25
;
Ghast
z
;
Ghast
resultado
;
SpawnPoint
PolloCrudo
z
=
x
:
+
y
;
dropperSpider
(
"Suma flotante: "
bind
z
)
;
z
=
x
:
-
y
;
dropperSpider
(
"Resta flotante: "
bind
z
)
;
z
=
x
:
*
y
;
dropperSpider
(
"Multiplicación flotante: "
bind
z
)
;
z
=
x
:
y
;
dropperSpider
(
"División flotante: "
bind
z
)
;
z
=
x
:
%
y
;
dropperSpider
(
"Módulo flotante: "
bind
z
)
;
resultado
=
x
:
+
y
:
*
z
;
dropperSpider
(
"x :+ y :* z = "
bind
resultado
)
;
resultado
=
(
x
:
+
y
)
:
*
z
;
dropperSpider
(
"(x :+ y) :* z = "
bind
resultado
)
;
resultado
=
x
:
+
y
:
+
z
;
dropperSpider
(
"x :+ y :+ z = "
bind
resultado
)
;
resultado
=
x
:
*
y
:
z
:
+
x
:
-
y
;
dropperSpider
(
"x :* y :// z :+ x :- y = "
bind
resultado
)
;
resultado
=
-
x
;
dropperSpider
(
"-x = "
bind
resultado
)
;
resultado
=
5.5
:
+
3.2
;
dropperSpider
(
"5.5 :+ 3.2 = "
bind
resultado
)
;
resultado
=
-
(
x
:
+
y
)
;
dropperSpider
(
"-(x :+ y) = "
bind
resultado
)
;
resultado
=
x
:
+
y
;
resultado
=
x
:
-
y
;
resultado
=
x
:
*
y
;
resultado
=
x
:
y
;
resultado
=
x
:
%
y
;
resultado
=
x
:
+
y
;
resultado
=
x
:
-
y
;
resultado
=
x
:
*
y
;
resultado
=
x
:
y
;
resultado
=
x
:
%
y
;
resultado
=
x
:
+
y
;
resultado
=
x
:
*
y
;
resultado
=
(
(
(
(
x
:
+
y
)
:
*
z
)
:
2.0
)
:
%
10.0
)
;
Ghast
mezcla1
=
x
:
+
5
;
Ghast
mezcla2
=
3.5
:
*
y
;
Ghast
mezcla3
=
x
:
+
(
y
:
*
2.0
)
:
1.5
;
Spider
texto
=
"Notch:Engine"
;
Stack
entero
=
(
x
:
+
y
)
>
>
Stack
;
PolloAsado
worldSave
WorldName
PruebaOpComparacion
:
Inventory
Stack
a
=
10
;
Stack
b
=
5
;
Torch
resultado
;
Ghast
x
=
3.5
;
Ghast
y
=
2.75
;
Spider
cadena1
=
"abc"
;
Spider
cadena2
=
"def"
;
Rune
char1
=
'A'
;
Rune
char2
=
'B'
;
Torch
bool1
=
On
;
Torch
bool2
=
Off
;
SpawnPoint
PolloCrudo
resultado
=
a
<
b
;
dropperSpider
(
"a < b: "
bind
resultado
)
;
resultado
=
x
<
y
;
dropperSpider
(
"x < y: "
bind
resultado
)
;
resultado
=
cadena1
<
cadena2
;
dropperSpider
(
"cadena1 < cadena2: "
bind
resultado
)
;
resultado
=
char1
<
char2
;
dropperSpider
(
"char1 < char2: "
bind
resultado
)
;
resultado
=
a
>
b
;
dropperSpider
(
"a > b: "
bind
resultado
)
;
resultado
=
x
>
y
;
dropperSpider
(
"x > y: "
bind
resultado
)
;
resultado
=
a
<=
b
;
dropperSpider
(
"a <= b: "
bind
resultado
)
;
resultado
=
x
<=
y
;
dropperSpider
(
"x <= y: "
bind
resultado
)
;
resultado
=
a
>=
b
;
dropperSpider
(
"a >= b: "
bind
resultado
)
;
resultado
=
x
>=
y
;
dropperSpider
(
"x >= y: "
bind
resultado
)
;
resultado
=
a
is
b
;
dropperSpider
(
"a is b: "
bind
resultado
)
;
resultado
=
x
is
y
;
dropperSpider
(
"x is y: "
bind
resultado
)
;
resultado
=
cadena1
is
cadena2
;
dropperSpider
(
"cadena1 is cadena2: "
bind
resultado
)
;
resultado
=
bool1
is
bool2
;
dropperSpider
(
"bool1 is bool2: "
bind
resultado
)
;
resultado
=
a
isNot
b
;
dropperSpider
(
"a isNot b: "
bind
resultado
)
;
resultado
=
x
isNot
y
;
dropperSpider
(
"x isNot y: "
bind
resultado
)
;
resultado
=
cadena1
isNot
cadena2
;
dropperSpider
(
"cadena1 isNot cadena2: "
bind
resultado
)
;
resultado
=
bool1
isNot
bool2
;
dropperSpider
(
"bool1 isNot bool2: "
bind
resultado
)
;
resultado
=
a
<
b
;
resultado
=
a
>
b
;
resultado
=
a
<=
b
;
resultado
=
a
>=
b
;
resultado
=
aisb
;
resultado
=
a
is
b
;
resultado
=
aisNotb
;
resultado
=
a
isNot
b
;
resultado
=
a
<
b
;
resultado
=
a
>
b
;
resultado
=
a
<=
b
;
resultado
=
a
>=
b
;
resultado
=
a
is
b
;
resultado
=
a
isNot
b
;
target
a
<
b
craft
hit
PolloCrudo
dropperSpider
(
"a es menor que b"
)
;
PolloAsado
repeater
x
>
y
craft
PolloCrudo
dropperSpider
(
"x es mayor que y"
)
;
PolloAsado
resultado
=
(
a
+
b
)
>
(
x
:
+
y
)
;
resultado
=
a
*
2
<=
b
*
3
;
resultado
=
(
a
2
)
is
(
b
1
)
;
resultado
=
bind
(
cadena1
,
cadena2
)
isNot
"abcdef"
;
Spider
islandia
=
"país"
;
Stack
isNotacion
=
42
;
PolloAsado
worldSave
WorldName
PruebaOpAsignacion
:
Inventory
Stack
contador
=
10
;
Stack
acumulador
=
0
;
Ghast
decimal
=
5.5
;
Spider
texto
=
"Notch"
;
Shelf
[
5
]
Stack
arreglo
;
Entity
Punto
PolloCrudo
Stack
x
;
Stack
y
;
PolloAsado
;
Entity
Punto
punto
;
SpawnPoint
PolloCrudo
contador
=
5
;
dropperSpider
(
"Asignación simple: "
bind
contador
)
;
decimal
=
3.14
;
texto
=
"Engine"
;
contador
+
=
3
;
dropperSpider
(
"Asignación con suma: "
bind
contador
)
;
acumulador
=
0
;
acumulador
+
=
contador
;
acumulador
+
=
2
;
dropperSpider
(
"Acumulador después de += : "
bind
acumulador
)
;
contador
-
=
2
;
dropperSpider
(
"Asignación con resta: "
bind
contador
)
;
acumulador
=
20
;
acumulador
-
=
5
;
acumulador
-
=
contador
;
dropperSpider
(
"Acumulador después de -= : "
bind
acumulador
)
;
contador
*
=
3
;
dropperSpider
(
"Asignación con multiplicación: "
bind
contador
)
;
acumulador
=
2
;
acumulador
*
=
contador
;
dropperSpider
(
"Acumulador después de *= : "
bind
acumulador
)
;
contador
=
2
;
dropperSpider
(
"Asignación con división: "
bind
contador
)
;
acumulador
=
50
;
acumulador
=
5
;
dropperSpider
(
"Acumulador después de /= : "
bind
acumulador
)
;
contador
%
=
3
;
dropperSpider
(
"Asignación con módulo: "
bind
contador
)
;
acumulador
=
17
;
acumulador
%
=
5
;
dropperSpider
(
"Acumulador después de %= : "
bind
acumulador
)
;
arreglo
[
0
]
=
10
;
arreglo
[
1
]
=
20
;
arreglo
[
2
]
=
30
;
arreglo
[
0
]
+
=
5
;
dropperSpider
(
"arreglo[0] después de += : "
bind
arreglo
[
0
]
)
;
arreglo
[
1
]
-
=
5
;
dropperSpider
(
"arreglo[1] después de -= : "
bind
arreglo
[
1
]
)
;
arreglo
[
2
]
*
=
2
;
dropperSpider
(
"arreglo[2] después de *= : "
bind
arreglo
[
2
]
)
;
punto
@
x
=
10
;
punto
@
y
=
20
;
punto
@
x
+
=
5
;
dropperSpider
(
"punto@x después de += : "
bind
punto
@
x
)
;
punto
@
y
-
=
8
;
dropperSpider
(
"punto@y después de -= : "
bind
punto
@
y
)
;
contador
=
5
;
contador
+
=
3
;
contador
-
=
2
;
contador
*
=
4
;
contador
=
2
;
contador
%
=
3
;
contador
=
5
;
contador
+
=
3
;
contador
-
=
2
;
contador
*
=
4
;
contador
=
2
;
contador
%
=
3
;
contador
=
10
;
contador
+
=
5
;
Stack
a
=
1
,
b
=
2
,
c
=
3
;
contador
=
(
a
+
b
)
*
c
;
contador
+
=
a
*
b
;
contador
-
=
a
+
b
;
contador
*
=
(
a
*
2
)
+
(
b
*
3
)
;
contador
=
a
+
1
;
contador
%
=
b
*
2
;
a
=
10
;
b
=
20
;
c
=
30
;
Spider
igual_texto
=
"Este texto tiene un signo = dentro"
;
Spider
mas_texto
=
"Este texto tiene un signo + dentro"
;
Spider
menos_texto
=
"Este texto tiene un signo - dentro"
;
Spider
por_texto
=
"Este texto tiene un signo * dentro"
;
Spider
div_texto
=
"Este texto tiene un signo / dentro"
;
Spider
mod_texto
=
"Este texto tiene un signo % dentro"
;
PolloAsado
worldSave
WorldName
PruebaOpAcceso
:
Inventory
Shelf
[
5
]
Stack
numeros
;
Shelf
[
3
]
Shelf
[
3
]
matriz
;
Shelf
[
2
]
Shelf
[
2
]
Shelf
[
2
]
cubo
;
Spider
texto
=
"Notch Engine"
;
Entity
Punto
PolloCrudo
Stack
x
;
Stack
y
;
Stack
z
;
PolloAsado
;
Entity
Punto
punto
;
Entity
Persona
PolloCrudo
Spider
nombre
;
Stack
edad
;
Torch
activo
;
Shelf
[
3
]
Stack
notas
;
PolloAsado
;
Entity
Persona
estudiante
;
Shelf
[
3
]
Entity
Punto
puntos
;
Entity
Contenedor
PolloCrudo
Shelf
[
5
]
Stack
valores
;
Spider
etiqueta
;
PolloAsado
;
Entity
Contenedor
caja
;
SpawnPoint
PolloCrudo
numeros
[
0
]
=
10
;
numeros
[
1
]
=
20
;
numeros
[
2
]
=
30
;
Stack
valor
=
numeros
[
0
]
;
dropperSpider
(
"Valor en numeros[0]: "
bind
valor
)
;
Stack
indice
=
2
;
valor
=
numeros
[
indice
]
;
dropperSpider
(
"Valor en numeros[indice]: "
bind
valor
)
;
valor
=
numeros
[
1
+
1
]
;
dropperSpider
(
"Valor en numeros[1 + 1]: "
bind
valor
)
;
matriz
[
0
]
[
0
]
=
11
;
matriz
[
0
]
[
1
]
=
12
;
matriz
[
1
]
[
0
]
=
21
;
matriz
[
1
]
[
1
]
=
22
;
valor
=
matriz
[
1
]
[
1
]
;
dropperSpider
(
"Valor en matriz[1][1]: "
bind
valor
)
;
valor
=
matriz
[
indice
-
1
]
[
indice
-
1
]
;
dropperSpider
(
"Valor en matriz[indice - 1][indice - 1]: "
bind
valor
)
;
cubo
[
0
]
[
0
]
[
0
]
=
111
;
cubo
[
1
]
[
1
]
[
1
]
=
222
;
valor
=
cubo
[
1
]
[
1
]
[
1
]
;
dropperSpider
(
"Valor en cubo[1][1][1]: "
bind
valor
)
;
Rune
caracter
=
texto
[
0
]
;
dropperSpider
(
"Carácter en texto[0]: "
bind
caracter
)
;
caracter
=
texto
[
6
]
;
dropperSpider
(
"Carácter en texto[6]: "
bind
caracter
)
;
caracter
=
texto
[
indice
*
2
]
;
dropperSpider
(
"Carácter en texto[indice * 2]: "
bind
caracter
)
;
texto
[
0
]
=
'n'
;
dropperSpider
(
"Texto modificado: "
bind
texto
)
;
punto
@
x
=
10
;
punto
@
y
=
20
;
punto
@
z
=
30
;
valor
=
punto
@
x
;
dropperSpider
(
"Valor en punto@x: "
bind
valor
)
;
punto
@
y
=
punto
@
x
*
2
;
dropperSpider
(
"Valor en punto@y después de asignación: "
bind
punto
@
y
)
;
estudiante
@
nombre
=
"Steve"
;
estudiante
@
edad
=
25
;
estudiante
@
activo
=
On
;
estudiante
@
notas
[
0
]
=
85
;
estudiante
@
notas
[
1
]
=
90
;
estudiante
@
notas
[
2
]
=
95
;
Spider
nombre
=
estudiante
@
nombre
;
dropperSpider
(
"Nombre del estudiante: "
bind
nombre
)
;
Stack
nota
=
estudiante
@
notas
[
1
]
;
dropperSpider
(
"Segunda nota del estudiante: "
bind
nota
)
;
puntos
[
0
]
@
x
=
1
;
puntos
[
0
]
@
y
=
2
;
puntos
[
0
]
@
z
=
3
;
puntos
[
1
]
@
x
=
4
;
puntos
[
1
]
@
y
=
5
;
puntos
[
1
]
@
z
=
6
;
valor
=
puntos
[
1
]
@
y
;
dropperSpider
(
"Valor en puntos[1]@y: "
bind
valor
)
;
caja
@
etiqueta
=
"Items"
;
caja
@
valores
[
0
]
=
100
;
caja
@
valores
[
1
]
=
200
;
valor
=
caja
@
valores
[
1
]
;
dropperSpider
(
"Valor en caja@valores[1]: "
bind
valor
)
;
valor
=
numeros
[
0
]
;
nombre
=
estudiante
@
nombre
;
valor
=
numeros
[
0
]
;
valor
=
matriz
[
1
]
[
1
]
;
nombre
=
estudiante
@
nombre
;
valor
=
cubo
[
0
]
[
matriz
[
0
]
[
0
]
%
3
]
[
numeros
[
0
]
10
]
;
valor
=
numeros
[
0
]
;
nombre
=
estudiante
@
nombre
;
Spider
textoCuadrado
=
"Esto no es un [acceso]"
;
Spider
textoArroba
=
"Email: usuario@dominio.com"
;
PolloAsado
worldSave
WorldName
PruebaOpEspeciales
:
Bedrock
Obsidian
Stack
MAX_SIZE
1024
;
Inventory
Stack
entero
=
42
;
Ghast
flotante
=
3.14159
;
Spider
texto
=
"Notch Engine"
;
Rune
caracter
=
'A'
;
Torch
booleano
=
On
;
Shelf
[
5
]
Stack
arreglo
;
Chest
conjunto
=
{
:
1
,
2
,
3
:
}
;
Entity
Punto
PolloCrudo
Stack
x
;
Stack
y
;
PolloAsado
;
Entity
Punto
punto
;
SpawnPoint
PolloCrudo
Stack
tamanoStack
=
chunk
Stack
;
Stack
tamanoGhast
=
chunk
Ghast
;
Stack
tamanoSpider
=
chunk
Spider
;
Stack
tamanoRune
=
chunk
Rune
;
Stack
tamanoTorch
=
chunk
Torch
;
dropperSpider
(
"Tamaño de Stack en bytes: "
bind
tamanoStack
)
;
dropperSpider
(
"Tamaño de Ghast en bytes: "
bind
tamanoGhast
)
;
dropperSpider
(
"Tamaño de Spider en bytes: "
bind
tamanoSpider
)
;
dropperSpider
(
"Tamaño de Rune en bytes: "
bind
tamanoRune
)
;
dropperSpider
(
"Tamaño de Torch en bytes: "
bind
tamanoTorch
)
;
Stack
tamanoShelf
=
chunk
Shelf
[
5
]
Stack
;
Stack
tamanoChest
=
chunk
Chest
;
Stack
tamanoPunto
=
chunk
Punto
;
dropperSpider
(
"Tamaño de arreglo en bytes: "
bind
tamanoShelf
)
;
dropperSpider
(
"Tamaño de conjunto en bytes: "
bind
tamanoChest
)
;
dropperSpider
(
"Tamaño de Punto en bytes: "
bind
tamanoPunto
)
;
Stack
tamanoVariable
=
chunk
entero
;
Stack
tamanoArreglo
=
chunk
arreglo
;
Stack
tamanoTexto
=
chunk
texto
;
dropperSpider
(
"Tamaño de variable entero en bytes: "
bind
tamanoVariable
)
;
dropperSpider
(
"Tamaño de variable arreglo en bytes: "
bind
tamanoArreglo
)
;
dropperSpider
(
"Tamaño de variable texto en bytes: "
bind
tamanoTexto
)
;
Stack
tamanoExpresion
=
chunk
(
entero
*
2
+
10
)
;
dropperSpider
(
"Tamaño de expresión en bytes: "
bind
tamanoExpresion
)
;
Stack
enteroDeFlotante
=
flotante
>
>
Stack
;
dropperSpider
(
"Flotante convertido a entero: "
bind
enteroDeFlotante
)
;
Torch
booleanoDeEntero
=
entero
>
>
Torch
;
dropperSpider
(
"Entero convertido a booleano: "
bind
booleanoDeEntero
)
;
Rune
caracterDeTexto
=
texto
>
>
Rune
;
dropperSpider
(
"Primer carácter del texto: "
bind
caracterDeTexto
)
;
Stack
resultadoEntero
=
(
flotante
:
+
2.5
)
>
>
Stack
;
dropperSpider
(
"Suma flotante convertida a entero: "
bind
resultadoEntero
)
;
Stack
tam1
=
chunkStack
;
Stack
tam2
=
chunk
Stack
;
Stack
tam3
=
chunk
(
Stack
)
;
Stack
ent1
=
flotante
>
>
Stack
;
Stack
ent2
=
flotante
>
>
Stack
;
Stack
tam4
=
chunk
Stack
;
Stack
ent3
=
flotante
>
>
Stack
;
Stack
tam5
=
chunk
Stack
;
Stack
ent4
=
flotante
>
>
Stack
;
Stack
tamCombinado
=
chunk
(
flotante
>
>
Stack
)
;
Spider
textoMayor
=
"Esto no es una coherción >>"
;
Spider
textoChunk
=
"La palabra chunk no es un operador aquí"
;
Stack
resultado
=
(
flotante
:
*
2.0
>
>
Stack
)
+
(
entero
*
3
)
;
target
(
flotante
>
>
Stack
)
>
3
craft
hit
PolloCrudo
dropperSpider
(
"La parte entera de flotante es mayor que 3"
)
;
PolloAsado
PolloAsado
worldSave
WorldName
PruebaComLinea
:
Bedrock
Obsidian
Stack
MAX_LEVEL
100
;
Obsidian
Spider
VERSION
"1.0"
;
Inventory
Stack
contador
=
0
;
Spider
texto
=
"Notch Engine"
;
Rune
inicial
;
Stack
a
=
10
,
b
=
20
;
Recipe
Spell
calcular
(
Stack
::
a
,
b
)
->
Stack
;
CraftingTable
Spell
calcular
(
Stack
::
a
,
b
)
->
Stack
PolloCrudo
Stack
resultado
=
a
+
b
;
respawn
resultado
;
PolloAsado
Ritual
mostrarMensaje
(
Spider
::
mensaje
)
PolloCrudo
dropperSpider
(
mensaje
)
;
PolloAsado
SpawnPoint
PolloCrudo
contador
=
5
;
target
contador
>
0
craft
hit
PolloCrudo
dropperSpider
(
"Contador positivo"
)
;
PolloAsado
Stack
resultado
=
contador
+
10
;
Stack
suma
=
calcular
(
5
,
10
)
;
;
PolloAsado
worldSave
WorldName
PruebaComBloque
:
Bedrock
Obsidian
Stack
MAX_LEVEL
100
;
Obsidian
Spider
VERSION
"1.0"
;
Inventory
Stack
contador
=
0
;
Spider
texto
=
"Notch Engine"
;
Rune
inicial
;
Stack
a
=
10
,
b
=
20
;
Recipe
Spell
calcular
(
Stack
::
a
,
b
)
->
Stack
;
CraftingTable
Spell
calcular
(
Stack
::
a
,
b
)
->
Stack
PolloCrudo
Stack
resultado
=
a
+
b
;
respawn
resultado
;
PolloAsado
Ritual
mostrarMensaje
(
Spider
::
mensaje
)
PolloCrudo
dropperSpider
(
mensaje
)
;
PolloAsado
SpawnPoint
PolloCrudo
contador
=
5
+
10
;
target
contador
>
0
craft
hit
PolloCrudo
dropperSpider
(
"Contador positivo"
)
;
PolloAsado
dentro
pero
sin
cerrar
aún
*
secuencias
*
PolloAsado
worldSave
WorldName
PruebaComentarios
:
Inventory
Stack
contador
=
10
;
Spider
texto
=
"Comentario /* falso */ dentro de un string"
;
Rune
caracter
=
'*'
;
SpawnPoint
PolloCrudo
dropperSpider
(
"Los comentarios son importantes"
)
;
PolloAsado
worldSave
WorldName
PruebaIdentificadoresSimples
:
Bedrock
Obsidian
Stack
MAX
100
;
Obsidian
Spider
TITULO
"Notch Engine"
;
Inventory
Stack
a
;
Stack
contador
;
Stack
nivel
;
Stack
x
;
Stack
y
;
Stack
z
;
Stack
posicion
;
Stack
altura
;
Stack
ancho
;
Spider
nombre
;
Spider
texto
;
Spider
mensaje
;
Spider
saludo
;
Torch
activo
;
Torch
visible
;
Torch
terminado
;
Rune
inicial
;
Rune
caracter
;
Rune
simbolo
;
Ghast
pi
;
Ghast
temperatura
;
Ghast
velocidad
;
Stack
Contador
;
Spider
Nombre
;
Torch
Activo
;
Stack
i
;
Stack
j
;
Stack
k
;
Rune
c
;
Spider
s
;
Torch
b
;
Ghast
f
;
CraftingTable
Spell
suma
(
Stack
::
a
,
b
)
->
Stack
PolloCrudo
Stack
resultado
;
resultado
=
a
+
b
;
respawn
resultado
;
PolloAsado
Ritual
imprimir
(
Spider
::
mensaje
)
PolloCrudo
dropperSpider
(
mensaje
)
;
PolloAsado
SpawnPoint
PolloCrudo
Stack
valor
;
Stack
resultado
;
Spider
mensaje
;
valor
=
10
;
mensaje
=
"Hola"
;
resultado
=
valor
+
5
;
valor
=
suma
(
valor
,
20
)
;
ender_pearl
imprimir
(
mensaje
)
;
PolloAsado
worldSave
WorldName
PruebaIdentificadoresComplejos
:
Bedrock
Obsidian
Stack
MAX_LEVEL
100
;
Obsidian
Stack
MIN_LEVEL
1
;
Obsidian
Spider
GAME_TITLE
"Notch Engine"
;
Obsidian
Spider
VERSION_1_0
"v1.0"
;
Inventory
Stack
player_level
;
Stack
enemy_count
;
Stack
max_health
;
Stack
min_damage
;
Stack
current_position_x
;
Stack
counter1
;
Stack
item2
;
Stack
level3d
;
Stack
position2d
;
Stack
player1_health
;
Stack
item_1
;
Stack
player_2_score
;
Stack
enemy_level_3
;
Stack
position_x_1
;
Stack
inventory_slot_5
;
Stack
_temp
;
Stack
_internal_counter
;
Stack
_system_value
;
Stack
_player_data
;
Stack
very_long_variable_name_with_many_words
;
Spider
extremely_long_message_text_that_describes_something_in_detail
;
Torch
is_player_currently_in_creative_mode_with_flight_enabled
;
Stack
player5_current_health_max_100
;
Stack
enemy_3d_position_coordinate_x_12
;
Rune
player_initial_1
;
Spider
user_5_name
;
CraftingTable
Spell
calculate_total_damage
(
Stack
::
base_damage
,
critical_multiplier
;
Torch
::
is_headshot
)
->
Stack
PolloCrudo
Stack
total_damage
;
total_damage
=
base_damage
*
critical_multiplier
;
target
is_headshot
craft
hit
PolloCrudo
total_damage
=
total_damage
*
2
;
PolloAsado
respawn
total_damage
;
PolloAsado
Ritual
display_player_stats
(
Spider
::
player_name
;
Stack
level_1
,
health_points_100
)
PolloCrudo
dropperSpider
(
"Player: "
bind
player_name
)
;
dropperSpider
(
"Level: "
bind
level_1
)
;
dropperSpider
(
"Health: "
bind
health_points_100
)
;
PolloAsado
SpawnPoint
PolloCrudo
Stack
player1_health
=
100
;
Stack
enemy_count_5
=
10
;
Spider
main_player_name
=
"Steve_123"
;
player1_health
=
player1_health
-
20
;
enemy_count_5
=
calculate_total_damage
(
10
,
2
,
On
)
;
ender_pearl
display_player_stats
(
main_player_name
,
5
,
player1_health
)
;
Stack
___special_value
=
42
;
dropperStack
(
___special_value
)
;
PolloAsado
worldSave
WorldName
PruebaIdentificadoresSimilares
:
Bedrock
Obsidian
Stack
WorldNameTest
100
;
Obsidian
Spider
BedrockType
"Hard Stone"
;
Obsidian
Torch
InventoryFull
On
;
Inventory
Stack
worldname
;
Stack
WorldName2
;
Stack
bedrock
;
Stack
Bedrock_Type
;
Stack
inventory
;
Stack
InventorySlot
;
Stack
recipe
;
Stack
RecipeBook
;
Stack
craftingtable
;
Stack
CraftingTable2
;
Stack
spawnpoint
;
Stack
SpawnPoint_Main
;
Stack
stack
;
Spider
spider
;
Torch
torch
;
Rune
rune
;
Ghast
ghast
;
Chest
chest
;
Book
book
;
Stack
pollocrudo
;
Stack
PolloAsado
;
Stack
polloAsadoExtra
;
Stack
repeater
;
Stack
target
;
Stack
hit
;
Stack
miss
;
Stack
craft
;
Stack
jukebox
;
Stack
disc
;
Stack
silence
;
Stack
spawner
;
Stack
exhausted
;
Stack
walk
;
Stack
set
;
Stack
to
;
Stack
step
;
Stack
wither
;
Stack
creeper
;
Stack
enderPearl
;
Stack
enderpearlitem
;
Stack
ragequit
;
Stack
spell
;
Stack
Spell_Cast
;
Stack
ritual
;
Stack
RitualCeremony
;
Stack
respawn
;
Stack
respawnPoint
;
Stack
ender_pearl
;
Stack
enderpearlTeleport
;
Stack
soulsand
;
Stack
SoulSandBlock
;
Stack
magma
;
Stack
MagmaBlock
;
Stack
and
;
Stack
andOperator
;
Stack
or
;
Stack
orGate
;
Stack
not
;
Stack
notOperator
;
Stack
xor
;
Stack
xorCalculation
;
Stack
is
;
Stack
isNot
;
Stack
isEqual
;
Torch
on
;
Torch
onSwitch
;
Torch
off
;
Torch
offState
;
Stack
hopper
;
Stack
hopperMinecart
;
Stack
dropper
;
Stack
dropperFunction
;
CraftingTable
Spell
worldNameGenerator
(
)
->
Spider
PolloCrudo
Spider
spawnpoint
=
"DefaultSpawn"
;
Stack
craft
=
10
;
Spider
ritual
=
"Magic"
;
respawn
"Generated"
;
PolloAsado
Ritual
craftingTableMaker
(
Spider
::
recipe
;
Stack
inventory
)
PolloCrudo
Stack
spell
=
20
;
Stack
worldname
=
30
;
Torch
on
=
Off
;
dropperSpider
(
"Crafting table ready"
)
;
PolloAsado
SpawnPoint
PolloCrudo
Stack
worldname
=
1
;
Stack
bedrock
=
2
;
Stack
inventory
=
3
;
Stack
recipe
=
4
;
Stack
craftingtable
=
5
;
Stack
spawnpoint
=
6
;
worldname
=
worldname
+
bedrock
;
inventory
=
craftingtable
*
spawnpoint
;
target
worldname
>
recipe
craft
hit
PolloCrudo
Spider
spell
=
"Magic"
;
dropperSpider
(
spell
)
;
PolloAsado
Spider
generatedName
=
worldNameGenerator
(
)
;
ender_pearl
craftingTableMaker
(
"New Recipe"
,
inventory
)
;
PolloAsado
worldSave
WorldName
PruebaStringsLargos
:
Inventory
Spider
string_normal
=
"Este es un string normal"
;
Spider
string_largo
=
"Este es un string extremadamente largo para probar cómo maneja el analizador léxico los tokens de gran tamaño. El propósito es verificar si el buffer del analizador puede manejar correctamente cadenas que exceden el tamaño típico. En Minecraft, los jugadores pueden construir estructuras enormes y elaboradas, similar a cómo este string se extiende más allá de los límites normales. Las cadenas largas son útiles para almacenar textos extensos como descripciones, historias, o mensajes de diálogo en juegos. Este string sigue creciendo para asegurar que supere los límites habituales de procesamiento del analizador léxico."
;
Spider
string_muy_largo
=
"Este string es aún más largo que el anterior, llegando a aproximadamente mil caracteres para poner realmente a prueba los límites del analizador léxico. En el desarrollo de compiladores, es importante verificar cómo responde el sistema ante casos extremos. Los buffers mal dimensionados podrían causar desbordamientos o truncamientos inesperados. En el mundo de Minecraft, esto sería comparable a construir una megaestructura que se extiende hasta los límites permitidos del mundo. Es crucial que el compilador maneje correctamente estos casos límite, ya que en aplicaciones reales, los usuarios pueden introducir textos extremadamente largos, como documentación, logs detallados, o incluso código generado automáticamente. Este string continúa creciendo, añadiendo más y más caracteres para asegurar que pruebe adecuadamente la capacidad del buffer del analizador léxico. Una implementación robusta debería ser capaz de manejar este token sin problemas, reconociéndolo correctamente como un único string literal, sin importar su longitud. El tamaño máximo debería estar limitado únicamente por la memoria disponible en el sistema, no por limitaciones arbitrarias en el diseño del analizador léxico. Este string sigue y sigue, añadiendo más palabras y caracteres, para garantizar que realmente ponga a prueba los límites del analizador."
;
Spider
string_con_escapes
=
"Este string incluye secuencias de escape como: \n nueva línea, \t tabulación, \" comillas dobles, \\ barra invertida, y otros caracteres especiales como !@#$%^&*()_+-={}[]|:;<>,.?/~`"
;
Spider
string_multilinea
=
"Línea 1\nLínea 2\nLínea 3\nLínea 4\nLínea 5\nLínea 6\nLínea 7\nLínea 8\nLínea 9\nLínea 10\nLínea 11\nLínea 12\nLínea 13\nLínea 14\nLínea 15\nLínea 16\nLínea 17\nLínea 18\nLínea 19\nLínea 20"
;
Spider
string_simbolos
=
"Este string contiene símbolos que son tokens en Notch Engine: +, -, *, //, %, :+, :-, :*, :%, ://, @, [], {}, {: :}, {/ /}, >>. También incluye palabras reservadas como WorldName, Inventory, SpawnPoint, craft, respawn, soulsand, magma, etc."
;
Spider
string_extremo
=
"Este string es extremadamente largo AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA, superando los dos mil caracteres para realmente llevar al límite la capacidad del analizador léxico. En el desarrollo de compiladores e intérpretes, es fundamental probar cómo maneja el sistema casos extremos como este. Cualquier limitación no prevista en el diseño podría manifestarse al procesar tokens de este tamaño. En Minecraft, esto sería equivalente a construir una estructura colosal que se extiende por miles de bloques en todas direcciones, poniendo a prueba los límites del motor del juego. Los analizadores léxicos deben estar preparados para manejar tokens de cualquier longitud razonable, ya que en aplicaciones del mundo real, los usuarios pueden necesitar procesar textos extremadamente largos. Ejemplos incluyen el procesamiento de documentos completos, archivos de configuración extensos, o incluso código generado automáticamente que puede extenderse por miles de líneas. Este string sigue creciendo, añadiendo más y más palabras y caracteres, para asegurar que realmente ponga a prueba los límites del buffer del analizador. Una implementación robusta debería manejar este token sin problemas, reconociéndolo correctamente como un único string literal completo, sin importar su tamaño. El tamaño máximo debería estar limitado únicamente por la memoria disponible en el sistema, no por limitaciones arbitrarias en el diseño del analizador. Este string continúa expandiéndose, añadiendo más contenido para garantizar que supere cualquier buffer de tamaño fijo que pueda haber sido implementado. Es importante también verificar que el rendimiento del analizador no se degrade exponencialmente con tokens muy grandes, lo que podría indicar algoritmos ineficientes. En el contexto de Notch Engine, inspirado en Minecraft, este string sería como un libro dentro del juego con una historia increíblemente detallada que se extiende por múltiples páginas. El analizador léxico debe procesar este token de manera eficiente, reconociéndolo como un único string literal y no fragmentándolo incorrectamente en múltiples tokens. Este string sigue creciendo, agregando más y más caracteres, para asegurar que realmente ponga a prueba los límites del analizador léxico. Continúa expandiéndose, como un mundo de Minecraft que se genera infinitamente, añadiendo más palabras y frases para llegar a una longitud verdaderamente extrema. Este string sigue y sigue y sigue, desafiando las capacidades del analizador, probando su robustez y eficiencia al manejar casos extremos como este."
;
SpawnPoint
PolloCrudo
dropperSpider
(
"Prueba de strings largos completada"
)
;
Stack
longitud
=
#
(
string_largo
)
;
dropperStack
(
longitud
)
;
Spider
subcadena
=
from
string_largo
#
#
0
#
#
50
;
dropperSpider
(
subcadena
)
;
PolloAsado
worldSave
WorldName
PruebaNumeroGrande
:
Bedrock
Obsidian
Stack
NUM_PEQUENO
42
;
Obsidian
Stack
NUM_MEDIANO
12345
;
Obsidian
Stack
NUM_GRANDE
9876543210
;
Obsidian
Stack
NUM_MUY_GRANDE
1234567890123456789
;
Obsidian
Stack
NEG_PEQUENO
-
42
;
Obsidian
Stack
NEG_MEDIANO
-
12345
;
Obsidian
Stack
NEG_GRANDE
-
9876543210
;
Obsidian
Stack
NEG_MUY_GRANDE
-
1234567890123456789
;
Obsidian
Stack
INT_16BIT_MAX
32767
;
Obsidian
Stack
INT_16BIT_MIN
-
32768
;
Obsidian
Stack
INT_32BIT_MAX
2147483647
;
Obsidian
Stack
INT_32BIT_MIN
-
2147483648
;
Obsidian
Stack
INT_64BIT_MAX
9223372036854775807
;
Obsidian
Stack
INT_64BIT_MIN
-
9223372036854775808
;
Obsidian
Stack
NUM_EXTREMO
123456789012345678901234567890
;
Obsidian
Stack
NEG_EXTREMO
-
123456789012345678901234567890
;
Inventory
Stack
num1
=
1234567890
;
Stack
num2
=
9876543210
;
Stack
grande1
=
123456789012345678
;
Stack
grande2
=
987654321098765432
;
Stack
max16
=
32767
;
Stack
min16
=
-
32768
;
Stack
max32
=
2147483647
;
Stack
min32
=
-
2147483648
;
Stack
max64
=
9223372036854775807
;
Stack
min64
=
-
9223372036854775808
;
Stack
extremo
=
123456789012345678901234567890
;
Shelf
[
2147483647
]
Stack
arregloGrande
;
Stack
suma
;
Stack
resta
;
Stack
multiplicacion
;
Stack
division
;
Stack
modulo
;
SpawnPoint
PolloCrudo
suma
=
num1
+
num2
;
resta
=
num2
-
num1
;
multiplicacion
=
num1
*
10
;
division
=
num2
10
;
modulo
=
num2
%
10
;
Stack
resultado1
=
grande1
+
grande2
;
Stack
resultado2
=
extremo
1000
;
Stack
posible_overflow
=
max32
+
1
;
Stack
posible_underflow
=
min32
-
1
;
Stack
producto_grande
=
grande1
*
grande2
;
Stack
division_extrema
=
extremo
3
;
dropperStack
(
suma
)
;
dropperStack
(
resta
)
;
dropperStack
(
multiplicacion
)
;
dropperStack
(
division
)
;
target
producto_grande
>
0
craft
hit
PolloCrudo
dropperSpider
(
"El resultado es positivo"
)
;
PolloAsado
Stack
i
=
0
;
repeater
i
<
5
craft
PolloCrudo
dropperStack
(
i
)
;
dropperStack
(
grande1
)
;
soulsand
i
;
PolloAsado
PolloAsado
worldSave
WorldName
PruebaPrecisionFlotante
:
Bedrock
Obsidian
Ghast
PI_SIMPLE
3.14
;
Obsidian
Ghast
PI_PRECISO
3.14159265358979323846
;
Obsidian
Ghast
EULER
2.71828182845904523536
;
Obsidian
Ghast
RAIZ_DOS
1.41421356237309504880
;
Obsidian
Ghast
PHI
1.61803398874989484820
;
Obsidian
Ghast
SPEED_OF_LIGHT
2.99792458
e8
;
Obsidian
Ghast
PLANCK_CONSTANT
6.62607015
e
-
34
;
Obsidian
Ghast
AVOGADRO
6.02214076
e23
;
Obsidian
Ghast
EXTREMO_PEQUENO
0.0000000000000000000000001
;
Obsidian
Ghast
EXTREMO_GRANDE
123456789012345678901234.5678901234567890
;
Obsidian
Ghast
NEG_PI
-
3.14159265358979
;
Obsidian
Ghast
NEG_EXTREMO
-
0.0000000000000000000000001
;
Obsidian
Ghast
CERO_DECIMAL
0.0
;
Obsidian
Ghast
SOLO_ENTERO
42.0
;
Obsidian
Ghast
SOLO_DECIMAL
0.42
;
Obsidian
Ghast
PUNTO_INICIAL
.
5
;
Inventory
Ghast
normal
=
3.14
;
Ghast
preciso
=
3.141592653589793
;
Ghast
pequeno
=
0.000000000123
;
Ghast
grande
=
1234567890.123456789
;
Ghast
punto_inicial
=
.
25
;
Ghast
sin_decimal
=
42
.
;
Ghast
cientifico1
=
1.23
e5
;
Ghast
cientifico2
=
4.56
e
-
7
;
Ghast
cientifico3
=
7.89
e
+
12
;
Ghast
muy_pequeno
=
0.000000000000000000000000000000000001
;
Ghast
muy_grande
=
999999999999999999999999999999999999999.9
;
Ghast
muchos_digitos
=
123456789012345.678901234567890
;
Ghast
neg_normal
=
-
3.14
;
Ghast
neg_preciso
=
-
3.141592653589793
;
Ghast
neg_pequeno
=
-
0.000000000123
;
Ghast
neg_cientifico
=
-
2.998
e8
;
Ghast
resultado1
;
Ghast
resultado2
;
Ghast
resultado3
;
SpawnPoint
PolloCrudo
resultado1
=
normal
:
+
preciso
;
resultado2
=
preciso
:
-
normal
;
resultado3
=
normal
:
*
2.0
;
Ghast
res_extremo1
=
muy_pequeno
:
*
1000000.0
;
Ghast
res_extremo2
=
muy_grande
:
1000000.0
;
Ghast
division1
=
1.0
:
3.0
;
Ghast
division2
=
2.0
:
3.0
;
Ghast
division_extrema
=
1.0
:
9999999999.0
;
Ghast
res_cientifico
=
cientifico1
:
*
cientifico2
;
dropperGhast
(
resultado1
)
;
dropperGhast
(
resultado2
)
;
dropperGhast
(
division1
)
;
dropperGhast
(
division2
)
;
target
division1
:
<
0.34
craft
hit
PolloCrudo
dropperSpider
(
"La división 1/3 es menor que 0.34"
)
;
PolloAsado
Ghast
i
=
0.0
;
repeater
i
:
<
1.0
craft
PolloCrudo
dropperGhast
(
i
)
;
i
=
i
:
+
0.2
;
PolloAsado
PolloAsado
worldSave
WorldName
PruebaComentarioLargo
:
Inventory
Stack
contador
=
0
;
Stack
despues_comentario
=
1
;
Spider
mensaje
=
"Prueba de comentarios largos"
;
SpawnPoint
PolloCrudo
Stack
i
=
0
;
repeater
i
<
5
craft
PolloCrudo
soulsand
i
;
dropperSpider
(
mensaje
bind
" - iteración "
bind
i
)
;
PolloAsado
dropperSpider
(
"Prueba de comentarios largos completada"
)
;
PolloAsado
worldSave
WorldName
PruebaTokensConsecutivos
:
Bedrock
Obsidian
Stack
MAX_LEVEL5
100
;
Obsidian
Stack
LEVEL_PLUS_SKILL
200
;
Obsidian
Stack
OFFSET_MINUS_5
50
;
Inventory
Stack
a
=
5
;
Stack
b
=
10
;
Stack
c
=
a
+
b
;
Stack
suma
=
5
+
3
;
Stack
resta
=
10
-
7
;
Stack
multiplicacion
=
4
*
3
;
Stack
division
=
20
4
;
Stack
modulo
=
7
%
2
;
Torch
comparacion1
=
5
<
10
;
Torch
comparacion2
=
5
>
3
;
Torch
comparacion3
=
5
<=
5
;
Torch
comparacion4
=
5
>=
5
;
Torch
comparacion5
=
5
is5
;
Torch
comparacion6
=
5
isNot6
;
Stack
expr1
=
5
+
3
*
2
;
Stack
expr2
=
(
5
+
3
)
*
2
;
Stack
expr3
=
5
+
(
3
*
2
)
;
Ghast
f1
=
3.14
;
Ghast
f2
=
f1
:
+
2.5
;
Ghast
f3
=
f1
:
-
1.5
;
Ghast
f4
=
f1
:
*
2.0
;
Ghast
f5
=
f1
:
1.5
;
Shelf
[
5
]
Stack
arreglo
;
Entity
Jugador
PolloCrudo
Spider
nombre
;
Stack
nivel
;
PolloAsado
;
Spider
texto
=
"Hola"
;
Rune
caracter
=
'A'
;
Torch
booleano
=
On
;
Stack
arr
[
0
]
=
10
;
Stack
x
=
1
,
y
=
2
,
z
=
3
;
Stack
normal1
=
10
;
Stack
normal2
=
20
;
Spider
mensaje
=
"Tokens consecutivos"
;
SpawnPoint
PolloCrudo
suma
=
normal1
+
normal2
;
Stack
valor
=
(
normal1
+
5
)
*
(
normal2
-
5
)
;
repeater
suma
>
0
hit
PolloCrudo
suma
=
suma
-
1
;
dropperStack
(
suma
)
;
PolloAsado
target
valor
>=
100
hit
PolloCrudo
dropperSpider
(
"Valor grande"
)
;
PolloAsado
miss
PolloCrudo
dropperSpider
(
"Valor pequeño"
)
;
PolloAsado
dropperSpider
(
mensaje
)
;
dropperStack
(
valor
)
;
normal1
+
=
5
;
normal2
-
=
3
;
dropperStack
(
normal1
)
;
dropperStack
(
normal2
)
;
PolloAsado
worldSave
WorldName
PruebaCaracteresInvalidos
:
Bedrock
Obsidian
Stack
NORMAL
100
;
Obsidian
Stack
ÑANDU
200
;
Obsidian
Stack
AÇÚCAR
300
;
Obsidian
Stack
CAFÉ
400
;
Inventory
Stack
contador
=
0
;
Spider
mensaje
=
"Normal"
;
Stack
año
=
2025
;
Stack
piña
=
10
;
Spider
münzen
=
"Monedas"
;
Spider
öffentlich
=
"Público"
;
Stack
cont
ador
=
5
;
Spider
mens
aje
=
"Texto"
;
Stack
contador
=
10
;
Spider
mensaje
=
"Texto"
;
Stack
monedas
=
100
;
Stack
valor
=
50
;
Spider
texto
=
"Copyright"
;
Spider
texto_unicode
=
"Caracteres especiales: áéíóúñÁÉÍÓÚÑ"
;
Spider
texto_emoji
=
"Emojis: 😀🎮🌍💻"
;
Stack
a
b
;
Stack
c
d
;
Stack
e
f
;
Stack
g
h
;
Stack
valor
otro
;
Stack
valor
contador
=
5
;
Stack
otro
valor
=
10
;
Rune
char_1
=
'€'
;
Rune
char_2
=
'✓'
;
SpawnPoint
PolloCrudo
contador
=
1
;
contador
=
contador
2
;
contador
=
contador
2
;
dropperStack
(
año
)
;
dropperSpider
(
texto_unicode
)
;
contador
=
5
10
;
contador
=
5
10
;
contador
=
5
;
contador
=
contador
+
5
;
dropperSpider
(
"Fin de prueba"
)
;
PolloAsado
worldSave
WorldName
PruebaStringNoTerminado
:
Bedrock
Obsidian
Spider
NOMBRE
"Notch Engine"
;
Obsidian
Spider
VERSION
"1.0"
;
Obsidian
Spider
DESCRIPCION
"Un lenguaje basado en Minecraft;
$$ Constante después del error para verificar recuperación
Obsidian Stack MAX_NIVEL 100;
Inventory
$$ Variables con strings correctamente terminados
Spider normal = "
Este
string
está
bien
";
Spider multilinea = "
Este
string
tiene
nmúltiples
líneas
ny
está
bien
terminado
";
$$ Variable con string no terminado - falta comilla de cierre
Spider incompleto = "
Este
string
no
está
terminado
;
Stack
contador
=
0
;
Spider
confuso
=
"Este string tiene una comilla escapada \" pero no está terminado;
$$ String no terminado al final de una línea
Spider final_linea = "
Este
string
termina
la
línea
pero
no
está
cerrado
Spider
siguiente
=
"Este es un nuevo string"
;
Spider
combinado
=
"String no terminado Stack contador = 5;
$$ String con múltiples líneas pero sin terminar
Spider multilinea_incompleto = "
Este
string
tiene
múltiples
líneas
pero
no
está
terminado
correctamente
;
Spider
comentario_inmediato
=
"String terminado correctamente"
Spider
comentario_error
=
"String no terminado$$ Comentario que no salva el error
$$ String no terminado con comentario de bloque al final
Spider bloque_inmediato = "
String
no
terminado
Spider
consecutivo1
=
"Primer string terminado"
;
Spider
consecutivo2
=
"Segundo string no terminado;
Spider consecutivo3 = "
Tercer
string
terminado
";
SpawnPoint
PolloCrudo
$$ Código normal para contraste
dropperSpider("
Este
mensaje
está
bien
formado
");
$$ Instrucción con string no terminado
dropperSpider("
Este
mensaje
no
está
terminado
;
contador
=
1
;
Spider
resultado
=
normal
bind
"Parte no terminada;
$$ String no terminado en una estructura de control
target normal is "
Comparación
no
terminada
craft
hit
PolloCrudo
dropperSpider
(
"Este código nunca se ejecutará"
)
;
PolloAsado
dropperSpider
(
"String final no terminado
PolloAsado
worldSave
$*
Prueba_Err_ComentarioNoTerminado.ne
Propósito: Verificar detección de comentarios de bloque sin cierre
Fecha: 28/04/2025
*$
WorldName PruebaComentarioNoTerminado:
Bedrock
$$ Constantes normales para contraste
Obsidian Stack MAX_LEVEL 100;
$* Comentario de bloque correctamente cerrado *$
Obsidian Stack MIN_LEVEL 1;
$* Comentario de bloque sin cierre - falta el terminador *$
Obsidian Stack MEDIO_LEVEL 50;
Inventory
$$ Variables normales para contraste
Stack contador = 0;
Spider mensaje = "
Hola
Mundo
";
$*
Comentario de bloque multi-línea correctamente terminado
con varias líneas de texto
*$
Stack variable_normal = 5;
$*
Comentario de bloque multi-línea sin terminar
Este comentario no tiene el terminador correspondiente
y debería generar un error
Torch activo = On; $$ Esta línea no debería ser reconocida como código
Stack valor = 10; $$ Esta línea no debería ser reconocida como código
$$ Variables después del error para verificar recuperación
Stack recuperacion = 20;
$* Otro comentario no terminado
con símbolos que podrían confundir al analizador:
* asterisco suelto
$ signo dólar suelto
*$ esto parece un terminador pero no lo es
$* esto parece un iniciador dentro del comentario
$$ Más código después del segundo comentario no terminado
Torch otra_variable = Off;
$* Comentario aparentemente cerrado, pero con un espacio entre * y $
que debería causar que no se reconozca como terminador * $
$$ Código después del tercer comentario no terminado
Stack tercera_recuperacion = 30;
$*
Este comentario tiene una secuencia que parece un terminador,
pero tiene caracteres en medio: *texto$
Por lo tanto, no está realmente terminado.
$$ Último código para verificar recuperación
Stack ultima_recuperacion = 40;
SpawnPoint
PolloCrudo
$$ Código normal para contraste
dropperSpider("
Inicio
de
programa
");
$* Comentario de bloque sin terminar en el SpawnPoint
Esta sección del código no debería ejecutarse
contador = 5;
dropperStack(contador);
$$ Código después del comentario no terminado
Stack final = 100;
dropperStack(final);
dropperSpider("
Fin
de
programa
");
PolloAsado
$$ Esto debería ser código después del SpawnPoint, que no es válido
$$ pero el analizador léxico igual debería procesarlo como tokens
$*
Comentario final sin terminar
Este es el último elemento del archivo
worldSave
$*
Prueba: 37_Prueba_Err_CaracterNoTerminado
Descripción: Verificar detección de literales de carácter sin cierre
Fecha: 28/04/2025
*$
WorldName PruebaCaracterNoTerminado:
Inventory
$$ Casos de caracteres correctamente formados (para comparación)
Rune letraCorrecta = 'A';
Rune digitoCorrecto = '5';
Rune simboloCorrecto = '@';
Rune escapeCorrecto = '\n';
$$ Casos de caracteres sin cierre (errores léxicos)
Rune errorSimple = 'B; $$ Falta comilla de cierre
Rune errorEscape = '\n; $$ Falta comilla de cierre después de secuencia de escape
$$ Caso con apertura pero sin contenido ni cierre
Rune errorVacio = '; $$ Solo comilla de apertura
$$ Caso con múltiples caracteres (error léxico)
Rune errorMultiple = 'ABC; $$ Múltiples caracteres y falta comilla de cierre
$$ Error dentro de una expresión
Stack valor = 5 + (3 * 'x); $$ Falta comilla de cierre en la expresión
SpawnPoint
PolloCrudo
$$ Este carácter inválido debería ser detectado
Rune pruebaError = 'Z;
dropperSpider("
Este
texto
no
debería
ser
alcanzado
debido
al
error
léxico
");
PolloAsado
worldSave
$*
Prueba: 38_Prueba_Err_SimboloDesconocido
Descripción: Verificar detección de símbolos no reconocidos
Fecha: 28/04/2025
*$
WorldName PruebaSimboloDesconocido:
Bedrock
$$ Símbolos válidos para comparación
Obsidian Stack MAX_VALUE 100;
$$ Símbolo no reconocido: flecha de asignación errónea
Obsidian Stack MIN_VALUE => 0; $$ => no es un símbolo válido
Inventory
$$ Símbolos válidos (para comparación)
Stack contador = 10;
Stack resultado = contador + 5;
$$ Símbolos no reconocidos
Stack valor1 = 5 ^ 2; $$ ^ (potencia) no es un símbolo válido
Stack valor2 = 10 \ 3; $$ \ no es un operador válido
Stack valor3 = valor1 ~ valor2; $$ ~ no es un operador válido
$$ Operadores malformados o incompletos
Stack valor4 = 3 : 4; $$ : solo no es un operador válido (debe ser :+, :-, etc.)
Stack valor5 = 7 / 2; $$ / no es válido (debe ser // para división entera)
$$ Uso de símbolos de otros lenguajes
Stack valor6 = 5 ** 2; $$ ** (potencia en Python) no es válido
Torch condicion = (valor5 == valor6); $$ == no es válido (debe ser 'is')
$$ Símbolo inválido en acceso a estructura
Stack elemento = numeros->0; $$ -> no es válido para acceso (debe ser [])
ResourcePack
$$ Símbolo inválido en declaración de tipo
Anvil Stack ==> Spider; $$ ==> no es un símbolo válido (debe ser ->)
SpawnPoint
PolloCrudo
$$ Operadores inválidos en expresiones
Stack a = 5;
Stack b = 10;
Stack c = a ||| b; $$ ||| no es un operador válido
$$ Símbolos inválidos en estructuras de control
target a < b craft hit
PolloCrudo
dropperSpider("
a
es
menor
que
b
");
PolloAsado
?> $$ ?> no es un símbolo válido
$$ Símbolo inválido como terminador de instrucción
Stack valor = 100#
PolloAsado
worldSave
$*
Prueba: 39_Prueba_Comb_Estructura
Descripción: Verificar estructura básica de un programa completo
Fecha: 28/04/2025
*$
WorldName PruebaEstructuraCompleta:
$$ Sección de constantes
Bedrock
Obsidian Stack MAX_NIVEL 100;
Obsidian Spider VERSION "
1.0
.
0
";
Obsidian Torch DEBUG_MODE Off;
Obsidian Ghast PI 3.14159;
$$ Sección de tipos
ResourcePack
Anvil Ghast -> Stack truncate;
Anvil Stack -> Spider;
$$ Definición de un tipo personalizado
Entity Jugador
PolloCrudo
Spider nombre;
Stack nivel;
Ghast salud;
Torch activo;
PolloAsado;
$$ Sección de variables
Inventory
$$ Variables básicas
Stack contador = 0;
Spider mensaje = "
Bienvenido
a
Notch
Engine
";
Torch juego_activo = On;
Ghast temperatura = 21.5;
Chest letras = {: 'a', 'b', 'c' :};
$$ Variables compuestas
Shelf[5] Stack inventario;
Entity Jugador steve;
$$ Sección de prototipos
Recipe
$$ Prototipo de función
Spell calcularDanio(Stack :: nivel, arma; Ghast ref multiplicador) -> Stack;
$$ Prototipo de procedimiento
Ritual mostrarEstado(Spider :: nombre; Stack nivel, salud);
$$ Sección de implementación de rutinas
CraftingTable
$$ Implementación de función
Spell calcularDanio(Stack :: nivel, arma; Ghast ref multiplicador) -> Stack
PolloCrudo
Stack danio_base = nivel * 2;
target arma is 1 hit
PolloCrudo
danio_base *= 2; $$ Arma mejorada
PolloAsado
multiplicador = 1.5; $$ Modificar parámetro por referencia
respawn danio_base;
PolloAsado
$$ Implementación de procedimiento
Ritual mostrarEstado(Spider :: nombre; Stack nivel, salud)
PolloCrudo
dropperSpider("
==
==
=
Estado
del
Jugador
==
==
=
");
dropperSpider("
Nombre
:
" bind nombre);
dropperSpider("
Nivel
:
" bind nivel);
dropperSpider("
Salud
:
" bind salud);
dropperSpider("
==
==
==
==
==
==
==
==
==
==
==
==
==
==
=
");
PolloAsado
$$ Punto de entrada del programa
SpawnPoint
PolloCrudo
$$ Inicialización
steve@nombre = "
Steve
";
steve@nivel = 1;
steve@salud = 20.0;
steve@activo = On;
$$ Entrada y salida
dropperSpider(mensaje);
dropperSpider("
Ingrese
su
nombre
:
");
Spider nombre_jugador = hopperSpider();
$$ Uso de estructuras de control
target #(nombre_jugador) > 0 hit
PolloCrudo
dropperSpider("
Hola
,
" bind nombre_jugador bind "
");
$$ Uso de funciones y procedimientos
Stack danio = calcularDanio(steve@nivel, 1, 1.0);
dropperSpider("
Tu
daño
base
es
:
" bind danio);
ender_pearl mostrarEstado(steve@nombre, steve@nivel, steve@salud);
$$ Bucle
repeater juego_activo
PolloCrudo
dropperSpider("
Continuar
jugando
(
On
Off
)
");
juego_activo = hopperTorch();
target juego_activo hit
PolloCrudo
soulsand steve@nivel;
dropperSpider("
Nivel
aumentado
a
:
" bind steve@nivel);
PolloAsado
PolloAsado
PolloAsado
miss
PolloCrudo
dropperSpider("
Nombre
no
válido
.
");
PolloAsado
$$ Otros tipos de bucles
Stack i = 0;
spawner
PolloCrudo
soulsand i;
inventario[i] = i * 10;
PolloAsado
exhausted i >= 5;
walk j set 0 to 4
PolloCrudo
dropperSpider("
Inventario
[
" bind j bind "
]
:
" bind inventario[j]);
PolloAsado
PolloAsado
worldSave
$*
Prueba: 40_Prueba_Comb_Declaraciones
Descripción: Verificar combinaciones de declaraciones de variables y constantes
Fecha: 28/04/2025
*$
WorldName PruebaCombinacionDeclaraciones:
$$ Sección de constantes con diferentes tipos y complejidades
Bedrock
$$ Constantes simples de tipos básicos
Obsidian Stack MAX_PLAYERS 8;
Obsidian Stack MIN_LEVEL 1;
Obsidian Torch DEBUG_MODE On;
Obsidian Spider GAME_TITLE "
Notch
Engine
";
Obsidian Rune SEPARATOR '_';
Obsidian Ghast GRAVITY 9.8;
$$ Constantes con expresiones
Obsidian Stack MAX_INVENTORY_SIZE 5 * 9;
Obsidian Stack TOTAL_SLOTS MAX_PLAYERS * MAX_INVENTORY_SIZE;
Obsidian Spider FULL_TITLE GAME_TITLE bind "
v1
.
0
";
Obsidian Ghast TERMINAL_VELOCITY GRAVITY :* 3.0;
$$ Constantes con expresiones más complejas
Obsidian Stack DAYS_IN_YEAR 365;
Obsidian Stack DAYS_IN_4_YEARS DAYS_IN_YEAR * 4 + 1;
Obsidian Torch IS_LEAP_YEAR (DAYS_IN_4_YEARS - (DAYS_IN_YEAR * 4)) is 1;
$$ Declaraciones de tipos con diferentes formas
ResourcePack
$$ Conversiones de tipos básicas
Anvil Ghast -> Stack;
Anvil Ghast -> Stack truncate;
Anvil Stack -> Spider;
Anvil Rune -> Stack safe;
$$ Declaraciones de entidades (registros)
Entity Item
PolloCrudo
Spider nombre;
Stack cantidad;
Stack durabilidad;
Torch stackeable;
PolloAsado;
Entity Jugador
PolloCrudo
Spider nombre;
Stack nivel;
Stack experiencia;
Ghast salud;
Ghast hambre;
Torch en_linea;
Entity Item item_principal;
PolloAsado;
Entity Posicion
PolloCrudo
Stack x;
Stack y;
Stack z;
PolloAsado;
$$ Tipos anidados
Entity Mundo
PolloCrudo
Spider nombre;
Stack seed;
Shelf[10] Entity Jugador jugadores;
Entity Posicion spawn;
PolloAsado;
$$ Sección de variables con diferentes formas de declaración e inicialización
Inventory
$$ Declaraciones simples sin inicialización
Stack contador;
Spider mensaje;
Torch estado;
Rune inicial;
Ghast temperatura;
$$ Declaraciones con inicialización
Stack nivel = 1;
Spider nombre = "
Steve
";
Torch activo = On;
Rune tecla = 'A';
Ghast pi = 3.14159;
$$ Declaraciones múltiples del mismo tipo
Stack x = 0, y = 0, z = 0;
Torch jugando = On, pausa = Off, sonido = On;
Ghast distancia = 0.0, velocidad = 5.0, aceleracion = 1.5;
$$ Declaraciones con resultados de expresiones
Stack suma = 5 + 10;
Stack producto = 4 * 25;
Spider saludo = "
Hola
" bind nombre;
Torch condicion = nivel > 5;
Ghast promedio = (10.5 :+ 20.7 :+ 15.3) :// 3.0;
$$ Declaraciones de tipos compuestos
Shelf[5] Stack inventario;
Shelf[3] Spider mensajes = ["
Hola
", "
Mundo
", "
"];
Shelf[2] Shelf[2] Stack matriz;
Chest numeros = {: 1, 2, 3, 4, 5 :};
Book archivo = {/ "
datos
.
txt
", 'E' /};
$$ Instancias de entidades (registros)
Entity Item espada;
Entity Jugador jugador1
PolloCrudo
nombre: "
Alex
";
nivel: 5;
experiencia: 150;
salud: 18.5;
hambre: 16.0;
en_linea: On;
item_principal:
PolloCrudo
nombre: "
Espada
de
diamante
";
cantidad: 1;
durabilidad: 1500;
stackeable: Off;
PolloAsado;
PolloAsado;
Entity Mundo mundo_principal;
SpawnPoint
PolloCrudo
$$ Inicialización de variables declaradas sin valor inicial
contador = 0;
mensaje = "
Variable
inicializada
en
el
punto
de
entrada
";
estado = Off;
inicial = 'Z';
temperatura = 22.5;
$$ Inicialización de variables compuestas
espada@nombre = "
Espada
de
hierro
";
espada@cantidad = 1;
espada@durabilidad = 250;
espada@stackeable = Off;
matriz[0][0] = 1;
matriz[0][1] = 2;
matriz[1][0] = 3;
matriz[1][1] = 4;
mundo_principal@nombre = "
Mundo
de
prueba
";
mundo_principal@seed = 12345;
mundo_principal@spawn@x = 0;
mundo_principal@spawn@y = 64;
mundo_principal@spawn@z = 0;
$$ Uso de constantes en asignaciones
Stack max_jugadores = MAX_PLAYERS;
dropperSpider(FULL_TITLE);
$$ Uso de referencias a variables en asignaciones
Stack total = nivel + jugador1@nivel;
dropperSpider("
Nivel
total
:
" bind total);
PolloAsado
worldSave
$*
Prueba: 41_Prueba_Comb_Expresiones
Descripción: Verificar expresiones aritméticas y lógicas complejas
Fecha: 28/04/2025
*$
WorldName PruebaExpresionesComplejas:
Bedrock
Obsidian Stack BASE_DAMAGE 10;
Obsidian Stack ARMOR_FACTOR 2;
Obsidian Ghast CRIT_MULTIPLIER 1.5;
Obsidian Torch USE_ADVANCED_FORMULAS On;
Inventory
$$ Variables para las pruebas
Stack a = 5;
Stack b = 10;
Stack c = 15;
Stack resultado_entero;
Ghast x = 2.5;
Ghast y = 3.7;
Ghast z = 1.2;
Ghast resultado_flotante;
Torch p = On;
Torch q = Off;
Torch r = On;
Torch resultado_logico;
Spider str1 = "
Notch
";
Spider str2 = "
Engine
";
Spider resultado_string;
Shelf[5] Stack valores = [10, 20, 30, 40, 50];
Entity Jugador
PolloCrudo
Spider nombre;
Stack nivel;
Ghast salud;
PolloAsado;
Entity Jugador jugador;
SpawnPoint
PolloCrudo
$$ 1. Expresiones aritméticas complejas con enteros
resultado_entero = a + b * c;
dropperSpider("
a
+
b
*
c
=
" bind resultado_entero);
resultado_entero = (a + b) * c;
dropperSpider("
(
a
+
b
)
*
c
=
" bind resultado_entero);
resultado_entero = a + b - c * 2 // 3 % 4;
dropperSpider("
a
+
b
-
c
*
2
3
%
4
=
" bind resultado_entero);
resultado_entero = (a + (b - (c * (2 // (3 % 4)))));
dropperSpider("
Anidada
enteros
:
" bind resultado_entero);
soulsand a;
resultado_entero = a + b;
magma b;
dropperSpider("
Después
de
incremento
decremento
:
" bind resultado_entero);
$$ 2. Expresiones aritméticas complejas con flotantes
resultado_flotante = x :+ y :* z;
dropperSpider("
x
:
+
y
:
*
z
=
" bind resultado_flotante);
resultado_flotante = (x :+ y) :* z;
dropperSpider("
(
x
:
+
y
)
:
*
z
=
" bind resultado_flotante);
resultado_flotante = x :+ y :- z :* 2.0 :// 0.5 :% 1.0;
dropperSpider("
x
:
+
y
:
-
z
:
*
2.0
:
0.5
:
%
1.0
=
" bind resultado_flotante);
resultado_flotante = (x :+ (y :- (z :* (2.0 :// (0.5 :% 1.0)))));
dropperSpider("
Anidada
flotantes
:
" bind resultado_flotante);
$$ 3. Expresiones lógicas complejas
resultado_logico = p and q;
dropperSpider("
p
and
q
=
" bind resultado_logico);
resultado_logico = p or q;
dropperSpider("
p
or
q
=
" bind resultado_logico);
resultado_logico = not p;
dropperSpider("
not
p
=
" bind resultado_logico);
resultado_logico = p xor q;
dropperSpider("
p
xor
q
=
" bind resultado_logico);
resultado_logico = p and q or r;
dropperSpider("
p
and
q
or
r
=
" bind resultado_logico);
resultado_logico = p and (q or r);
dropperSpider("
p
and
(
q
or
r
)
=
" bind resultado_logico);
resultado_logico = not (p and q) or (not r and p);
dropperSpider("
not
(
p
and
q
)
or
(
not
r
and
p
)
=
" bind resultado_logico);
$$ 4. Expresiones de comparación
resultado_logico = a < b;
dropperSpider("
a
<
b
=
" bind resultado_logico);
resultado_logico = a > c;
dropperSpider("
a
>
c
=
" bind resultado_logico);
resultado_logico = a <= b and b >= c;
dropperSpider("
a
<=
b
and
b
>=
c
=
" bind resultado_logico);
resultado_logico = (a is b) or (b is c);
dropperSpider("
(
a
is
b
)
or
(
b
is
c
)
=
" bind resultado_logico);
resultado_logico = a isNot b and b isNot c and a isNot c;
dropperSpider("
a
isNot
b
and
b
isNot
c
and
a
isNot
c
=
" bind resultado_logico);
$$ 5. Expresiones mixtas (combinando tipos)
resultado_logico = (a + b > c) and (x :+ y :> z);
dropperSpider("
(
a
+
b
>
c
)
and
(
x
:
+
y
:
>
z
)
=
" bind resultado_logico);
resultado_logico = (a < b) or (not p) and (x :< y);
dropperSpider("
(
a
<
b
)
or
(
not
p
)
and
(
x
:
<
y
)
=
" bind resultado_logico);
$$ 6. Expresiones con operaciones de cadenas
resultado_string = bind(str1, "
" bind str2);
dropperSpider("
bind
result
:
" bind resultado_string);
Stack longitud = #(resultado_string);
dropperSpider("
Length
:
" bind longitud);
resultado_string = from resultado_string ## 0 ## 5;
dropperSpider("
Substring
:
" bind resultado_string);
Stack pos = seek(resultado_string, "
tch
");
dropperSpider("
Position
of
'tch'
:
" bind pos);
$$ 7. Expresiones con accesos a estructuras
Stack valor_arreglo = valores[2] + valores[3] * valores[4];
dropperSpider("
Array
expression
:
" bind valor_arreglo);
jugador@nombre = "
Steve
";
jugador@nivel = 20;
jugador@salud = 18.5;
Stack nivel_con_bonus = jugador@nivel + 5;
dropperSpider("
Nivel
con
bonus
:
" bind nivel_con_bonus);
Torch nivel_alto = jugador@nivel > 15 and jugador@salud :> 15.0;
dropperSpider("
Nivel
alto
:
" bind nivel_alto);
$$ 8. Expresiones con conversiones de tipo
Stack entero_desde_float = x >> Stack;
dropperSpider("
Entero
desde
float
:
" bind entero_desde_float);
Torch bool_desde_entero = a >> Torch;
dropperSpider("
Booleano
desde
entero
:
" bind bool_desde_entero);
$$ 9. Expresiones extremadamente complejas que combinan múltiples elementos
Stack damage = BASE_DAMAGE + ((jugador@nivel // 2) * (valores[1] + valores[3] // 3));
dropperSpider("
Daño
calculado
:
" bind damage);
target USE_ADVANCED_FORMULAS craft hit
PolloCrudo
Ghast damage_final = ((damage >> Ghast) :* CRIT_MULTIPLIER) :// (1.0 :+ ((valores[4] // 10) >> Ghast));
dropperSpider("
Daño
final
(
fórmula
avanzada
)
:
" bind damage_final);
PolloAsado
miss
PolloCrudo
Stack damage_simple = damage * 2 // (ARMOR_FACTOR + (p and q >> Stack));
dropperSpider("
Daño
final
(
fórmula
simple
)
:
" bind damage_simple);
PolloAsado
PolloAsado
worldSave
$*
Prueba: 42_Prueba_Comb_Control.ne
Descripción: Verificar estructuras de control anidadas
Fecha: 28/04/2025
*$
WorldName PruebaControlAnidado:
Inventory
$$ Variables para las pruebas
Stack contador = 0;
Stack max_iteraciones = 5;
Stack resultado = 0;
Stack opcion = 2;
Torch condicion1 = On;
Torch condicion2 = Off;
Spider mensaje = "
Estructuras
de
control
anidadas
";
Spider resultado_texto = "
";
Shelf[5] Stack matriz = [1, 2, 3, 4, 5];
Entity Personaje
PolloCrudo
Spider nombre;
Stack nivel;
Torch activo;
PolloAsado;
Entity Personaje jugador;
SpawnPoint
dropperSpider(mensaje);
jugador@nombre = "
Steve
";
jugador@nivel = 1;
jugador@activo = On;
$$ 1. Condicionales anidados (if-then-else)
target jugador@nivel >= 1 craft hit
PolloCrudo
dropperSpider("
Nivel
suficiente
para
comenzar
");
target jugador@activo craft hit
PolloCrudo
dropperSpider("
Jugador
activo
");
target jugador@nombre is "
Steve
" craft hit
PolloCrudo
dropperSpider("
Bienvenido
,
Steve
");
soulsand jugador@nivel;
PolloAsado
miss
PolloCrudo
dropperSpider("
Bienvenido
,
jugador
desconocido
");
PolloAsado
PolloAsado
miss
PolloCrudo
dropperSpider("
Jugador
inactivo
.
Activando
.
.
.
");
jugador@activo = On;
PolloAsado
PolloAsado
miss
PolloCrudo
dropperSpider("
Nivel
insuficiente
para
comenzar
");
PolloAsado
$$ 2. Switch anidado dentro de if
target opcion > 0 craft hit
PolloCrudo
jukebox opcion craft
disc 1:
PolloCrudo
dropperSpider("
Opción
1
seleccionada
");
target condicion1 craft hit
PolloCrudo
dropperSpider("
Subopción
A
");
PolloAsado
miss
PolloCrudo
dropperSpider("
Subopción
B
");
PolloAsado
PolloAsado
disc 2:
PolloCrudo
dropperSpider("
Opción
2
seleccionada
");
jukebox jugador@nivel craft
disc 1:
PolloCrudo
dropperSpider("
Nivel
básico
");
PolloAsado
disc 2:
PolloCrudo
dropperSpider("
Nivel
intermedio
");
PolloAsado
silence:
PolloCrudo
dropperSpider("
Nivel
desconocido
");
PolloAsado
PolloAsado
silence:
PolloCrudo
dropperSpider("
Opción
no
reconocida
");
PolloAsado
PolloAsado
$$ 3. Bucles anidados - while dentro de for
walk i set 0 to 2 craft
PolloCrudo
dropperSpider("
Iteración
de
for
principal
:
" bind i);
Stack j = 0;
repeater j < 3 craft
PolloCrudo
dropperSpider("
Subiteración
de
while
:
" bind j);
resultado += (i * 10 + j);
soulsand j;
PolloAsado
PolloAsado
dropperSpider("
Resultado
acumulado
:
" bind resultado);
$$ 4. Bucle do-while con if anidado
contador = 0;
resultado = 0;
spawner
PolloCrudo
soulsand contador;
dropperSpider("
Iteración
do
-
while
:
" bind contador);
target contador % 2 is 0 craft hit
PolloCrudo
dropperSpider("
Número
par
detectado
");
resultado += contador;
PolloAsado
miss
PolloCrudo
dropperSpider("
Número
impar
detectado
");
resultado += contador * 2;
PolloAsado
PolloAsado
exhausted contador >= max_iteraciones;
dropperSpider("
Resultado
tras
do
-
while
:
" bind resultado);
$$ 5. Bucles for anidados con break y continue
resultado = 0;
walk i set 0 to 5 craft
PolloCrudo
target i is 3 craft hit
PolloCrudo
dropperSpider("
Saltando
iteración
i
=
3
");
enderPearl;
PolloAsado
dropperSpider("
For
externo
:
" bind i);
walk j set 0 to 3 craft
PolloCrudo
target i is 4 and j > 1 craft hit
PolloCrudo
dropperSpider("
Terminando
loop
interno
en
i
=
4
,
j
=
" bind j);
creeper;
PolloAsado
resultado += (i + j);
dropperSpider("
For
interno
:
j
=
" bind j bind "
,
suma
acumulada
=
" bind resultado);
PolloAsado
PolloAsado
$$ 6. Combinación compleja: with dentro de if-else dentro de while
contador = 0;
resultado = 0;
repeater contador < 3 craft
PolloCrudo
soulsand contador;
dropperSpider("
Iteración
while
principal
:
" bind contador);
target contador % 2 is 0 craft hit
PolloCrudo
wither jugador craft
PolloCrudo
activo = Off;
dropperSpider("
" bind nombre bind "
desactivado
temporalmente
");
spawner
PolloCrudo
soulsand nivel;
dropperSpider("
Incrementando
nivel
:
" bind nivel);
PolloAsado
exhausted nivel > contador + 2;
activo = On;
dropperSpider("
" bind nombre bind "
reactivado
con
nivel
" bind nivel);
PolloAsado
PolloAsado
miss
PolloCrudo
Stack temp_nivel = jugador@nivel;
repeater temp_nivel > 0 craft
PolloCrudo
dropperSpider("
Reduciendo
nivel
temporal
:
" bind temp_nivel);
target temp_nivel is 1 craft hit
PolloCrudo
dropperSpider("
Nivel
mínimo
alcanzado
");
creeper;
PolloAsado
magma temp_nivel;
PolloAsado
PolloAsado
PolloAsado
$$ 7. Estructuras de control con expresiones complejas en las condiciones
walk i set 0 to matriz[2] + matriz[4] // 2 craft
PolloCrudo
target (i * 2 <= matriz[i % 5]) and ((i % 2 is 0) or (i is matriz[0])) craft hit
PolloCrudo
dropperSpider("
Condición
compleja
satisfecha
en
i
=
" bind i);
resultado += i;
PolloAsado
PolloAsado
dropperSpider("
Resultado
final
:
" bind resultado);
$$ 8. Instrucción ragequit condicionada anidada
target contador >= max_iteraciones and resultado < 100 craft hit
PolloCrudo
target jugador@nivel < 5 craft hit
PolloCrudo
dropperSpider("
Condiciones
críticas
alcanzadas
.
Terminando
programa
.
");
ragequit;
PolloAsado
PolloAsado
dropperSpider("
Programa
completado
con
éxito
.
");
worldSave
$*
Prueba: 43_Prueba_Rend_MuchosTokens
Descripción: Verificar rendimiento con un archivo con miles de tokens
Fecha: 28/04/2025
*$
WorldName PruebaMuchosTokens:
Bedrock
Obsidian Stack MAX_ITERATIONS 1000;
Obsidian Stack ARRAY_SIZE 500;
Obsidian Stack STEP_VALUE 1;
Obsidian Spider TEST_NAME "
Prueba
de
rendimiento
con
muchos
tokens
";
ResourcePack
Entity TestData
PolloCrudo
Stack id;
Stack value;
Ghast weight;
Spider name;
Torch active;
PolloAsado;
Inventory
$$ Declaramos variables extensas para generar muchos tokens
Shelf[500] Stack numbers;
$$ Creamos un array grande de registros
Shelf[100] Entity TestData records;
$$ Variables para el procesamiento
Stack counter;
Stack sum;
Stack product;
Stack max_value;
Stack min_value;
Ghast average;
Stack i;
Stack j;
Stack k;
Stack temp;
Torch condition;
SpawnPoint
dropperSpider(TEST_NAME);
dropperSpider("
Inicializando
arrays
.
.
.
");
$$ Inicialización masiva del array de enteros
walk i set 0 to ARRAY_SIZE - 1 craft
PolloCrudo
numbers[i] = i * STEP_VALUE;
PolloAsado
$$ Inicialización del array de registros
walk i set 0 to 99 craft
PolloCrudo
records[i]@id = i;
records[i]@value = i * 10;
records[i]@weight = i :* 0.5;
records[i]@name = "
Item_
" bind i;
records[i]@active = i % 2 is 0;
PolloAsado
dropperSpider("
Realizando
cálculos
.
.
.
");
$$ Cálculos repetitivos generando miles de tokens
sum = 0;
product = 1;
max_value = numbers[0];
min_value = numbers[0];
$$ Bucle con muchas operaciones
walk i set 0 to ARRAY_SIZE - 1 craft
PolloCrudo
$$ Acumuladores simples
sum += numbers[i];
$$ Para evitar overflow, sólo multiplicamos los primeros 10 valores
target i < 10 craft hit
PolloCrudo
product *= numbers[i] + 1;
PolloAsado
$$ Cálculo de máximo y mínimo
target numbers[i] > max_value craft hit
PolloCrudo
max_value = numbers[i];
PolloAsado
target numbers[i] < min_value craft hit
PolloCrudo
min_value = numbers[i];
PolloAsado
$$ Operaciones condicionales adicionales
target i % 50 is 0 craft hit
PolloCrudo
dropperSpider("
Procesado
" bind i bind "
elementos
.
.
.
");
PolloAsado
PolloAsado
$$ Cálculo de promedio
average = sum >> Ghast :// (ARRAY_SIZE >> Ghast);
dropperSpider("
Procesamiento
completado
.
Resultados
:
");
dropperSpider("
Suma
total
:
" bind sum);
dropperSpider("
Producto
(
primeros
10
)
:
" bind product);
dropperSpider("
Valor
máximo
:
" bind max_value);
dropperSpider("
Valor
mínimo
:
" bind min_value);
dropperSpider("
Promedio
:
" bind average);
$$ Procesamiento de registros - para generar más tokens
dropperSpider("
Procesando
registros
.
.
.
");
counter = 0;
walk i set 0 to 99 craft
PolloCrudo
target records[i]@active craft hit
PolloCrudo
soulsand counter;
$$ Actualizar el valor basado en otros registros
walk j set 0 to i craft
PolloCrudo
records[i]@value += j;
PolloAsado
PolloAsado
PolloAsado
dropperSpider("
Registros
activos
:
" bind counter);
$$ Algoritmo de ordenamiento burbuja para generar aún más tokens
dropperSpider("
Ordenando
array
.
.
.
");
walk i set 0 to ARRAY_SIZE - 2 craft
PolloCrudo
walk j set 0 to ARRAY_SIZE - i - 2 craft
PolloCrudo
target numbers[j] > numbers[j + 1] craft hit
PolloCrudo
$$ Intercambio
temp = numbers[j];
numbers[j] = numbers[j + 1];
numbers[j + 1] = temp;
PolloAsado
PolloAsado
PolloAsado
dropperSpider("
Array
ordenado
.
");
$$ Búsqueda binaria para generar más tokens
dropperSpider("
Realizando
búsquedas
.
.
.
");
walk k set 0 to 20 craft
PolloCrudo
Stack valor_buscar = k * 25;
Stack inicio = 0;
Stack fin = ARRAY_SIZE - 1;
Stack medio;
Stack encontrado = 0;
repeater inicio <= fin craft
PolloCrudo
medio = (inicio + fin) // 2;
target numbers[medio] is valor_buscar craft hit
PolloCrudo
encontrado = 1;
creeper;
PolloAsado
target numbers[medio] < valor_buscar craft hit
PolloCrudo
inicio = medio + 1;
PolloAsado
miss
PolloCrudo
fin = medio - 1;
PolloAsado
PolloAsado
target encontrado craft hit
PolloCrudo
dropperSpider("
Valor
" bind valor_buscar bind "
encontrado
en
posición
" bind medio);
PolloAsado
miss
PolloCrudo
dropperSpider("
Valor
" bind valor_buscar bind "
no
encontrado
");
PolloAsado
PolloAsado
dropperSpider("
Prueba
de
rendimiento
completada
.
");
worldSave
$*
Prueba: 44_Prueba_Rend_TokensRepetidos
Descripción: Verificar rendimiento con patrones repetitivos
Fecha: 28/04/2025
*$
WorldName PruebaTokensRepetidos:
Bedrock
Obsidian Stack MAX_ITERATIONS 500;
Obsidian Stack PATTERN_LENGTH 20;
Inventory
$$ Variables para la prueba
Stack counter = 0;
Stack total = 0;
Stack temp = 0;
Torch flag = On;
SpawnPoint
dropperSpider("
Iniciando
prueba
de
rendimiento
con
tokens
repetitivos
");
$$ =================================================================
$$ Patrón 1: Repetición masiva de operaciones aritméticas
$$ =================================================================
counter = 0;
total = 0;
repeater counter < MAX_ITERATIONS craft
PolloCrudo
$$ Patrón de operaciones aritméticas que se repite
total = total + 1;
total = total - 1;
total = total + 2;
total = total - 1;
total = total + 3;
total = total - 2;
total = total * 2;
total = total // 2;
total = total + 5;
total = total % 10;
total = total + 1;
total = total - 1;
total = total + 2;
total = total - 1;
total = total + 3;
total = total - 2;
total = total * 2;
total = total // 2;
total = total + 5;
total = total % 10;
soulsand counter;
PolloAsado
dropperSpider("
Patrón
1
completado
.
Total
:
" bind total);
$$ =================================================================
$$ Patrón 2: Repetición masiva de operaciones lógicas
$$ =================================================================
counter = 0;
flag = On;
repeater counter < MAX_ITERATIONS craft
PolloCrudo
$$ Patrón de operaciones lógicas que se repite
flag = flag and On;
flag = flag or Off;
flag = not flag;
flag = flag and On;
flag = flag or Off;
flag = not flag;
flag = flag xor On;
flag = flag xor Off;
flag = flag and On;
flag = not flag;
flag = flag and On;
flag = flag or Off;
flag = not flag;
flag = flag and On;
flag = flag or Off;
flag = not flag;
flag = flag xor On;
flag = flag xor Off;
flag = flag and On;
flag = not flag;
soulsand counter;
PolloAsado
dropperSpider("
Patrón
2
completado
.
Estado
final
:
" bind flag);
$$ =================================================================
$$ Patrón 3: Repetición masiva de evaluaciones condicionales
$$ =================================================================
counter = 0;
total = 0;
repeater counter < MAX_ITERATIONS craft
PolloCrudo
$$ Patrón de condicionales que se repite
target counter % 2 is 0 craft hit
PolloCrudo
total += 1;
PolloAsado
miss
PolloCrudo
total += 2;
PolloAsado
target counter % 3 is 0 craft hit
PolloCrudo
total += 3;
PolloAsado
miss
PolloCrudo
total += 1;
PolloAsado
target counter % 5 is 0 craft hit
PolloCrudo
total += 5;
PolloAsado
miss
PolloCrudo
total += 2;
PolloAsado
target counter % 7 is 0 craft hit
PolloCrudo
total += 7;
PolloAsado
miss
PolloCrudo
total += 3;
PolloAsado
target total > 1000 craft hit
PolloCrudo
total = total % 1000;
PolloAsado
soulsand counter;
PolloAsado
dropperSpider("
Patrón
3
completado
.
Total
:
" bind total);
$$ =================================================================
$$ Patrón 4: Repetición masiva de incremento/decremento
$$ =================================================================
counter = 0;
total = 500;
repeater counter < MAX_ITERATIONS craft
PolloCrudo
$$ Patrón de incremento/decremento que se repite
soulsand total;
soulsand total;
soulsand total;
magma total;
magma total;
soulsand total;
soulsand total;
magma total;
soulsand total;
magma total;
soulsand total;
soulsand total;
soulsand total;
magma total;
magma total;
soulsand total;
soulsand total;
magma total;
soulsand total;
magma total;
soulsand counter;
PolloAsado
dropperSpider("
Patrón
4
completado
.
Total
:
" bind total);
$$ =================================================================
$$ Patrón 5: Repetición masiva de operaciones de asignación compuesta
$$ =================================================================
counter = 0;
total = 5;
repeater counter < MAX_ITERATIONS craft
PolloCrudo
$$ Patrón de asignaciones compuestas que se repite
total += 5;
total -= 2;
total *= 2;
total //= 2;
total %= 10;
total += 1;
total -= 1;
total *= 3;
total //= 3;
total %= 5;
total += 5;
total -= 2;
total *= 2;
total //= 2;
total %= 10;
total += 1;
total -= 1;
total *= 3;
total //= 3;
total %= 5;
soulsand counter;
PolloAsado
dropperSpider("
Patrón
5
completado
.
Total
:
" bind total);
$$ =================================================================
$$ Patrón 6: Repetición masiva de operadores de comparación
$$ =================================================================
counter = 0;
total = 0;
temp = 50;
repeater counter < MAX_ITERATIONS craft
PolloCrudo
$$ Patrón de comparaciones que se repite
target counter < temp craft hit total += 1; PolloAsado
target counter > temp craft hit total += 1; PolloAsado
target counter <= temp craft hit total += 1; PolloAsado
target counter >= temp craft hit total += 1; PolloAsado
target counter is temp craft hit total += 1; PolloAsado
target counter isNot temp craft hit total += 1; PolloAsado
target counter < 100 craft hit total += 1; PolloAsado
target counter > 0 craft hit total += 1; PolloAsado
target counter <= 100 craft hit total += 1; PolloAsado
target counter >= 0 craft hit total += 1; PolloAsado
target counter < temp craft hit total += 1; PolloAsado
target counter > temp craft hit total += 1; PolloAsado
target counter <= temp craft hit total += 1; PolloAsado
target counter >= temp craft hit total += 1; PolloAsado
target counter is temp craft hit total += 1; PolloAsado
target counter isNot temp craft hit total += 1; PolloAsado
target counter < 100 craft hit total += 1; PolloAsado
target counter > 0 craft hit total += 1; PolloAsado
target counter <= 100 craft hit total += 1; PolloAsado
target counter >= 0 craft hit total += 1; PolloAsado
soulsand counter;
PolloAsado
dropperSpider("
Patrón
6
completado
.
Total
:
" bind total);
dropperSpider("
Prueba
de
rendimiento
con
tokens
repetitivos
completada
.
");
worldSave
$*
Prueba: 45_Prueba_Rend_TokensVariados
Descripción: Verificar rendimiento con variedad de tokens mezclados
Fecha: 28/04/2025
*$
WorldName PruebaTokensVariados:
$$ Sección de constantes para controlar el tamaño de la prueba
Bedrock
Obsidian Stack ITERATIONS 100;
Obsidian Stack MAX_VALUE 1000;
Obsidian Stack ARRAY_SIZE 50;
Obsidian Spider TEST_NAME "
Prueba
de
rendimiento
con
tokens
variados
";
Obsidian Spider VERSION "
1.0
";
Obsidian Ghast PI 3.14159;
Obsidian Torch DEBUG_MODE On;
$$ Definiciones de tipos variados para generar diversidad de tokens
ResourcePack
Entity Posicion
PolloCrudo
Stack x;
Stack y;
Stack z;
PolloAsado;
Entity Item
PolloCrudo
Spider nombre;
Stack cantidad;
Stack durabilidad;
Ghast peso;
Torch consumible;
PolloAsado;
Entity Jugador
PolloCrudo
Spider nombre;
Stack nivel;
Ghast salud;
Entity Posicion posicion;
Shelf[10] Entity Item inventario;
PolloAsado;
Anvil Ghast -> Stack truncate;
Anvil Stack -> Spider;
Anvil Spider -> Stack;
Anvil Stack -> Torch;
Inventory
Stack contador = 0;
Stack suma = 0;
Stack producto = 1;
Ghast pi = 3.14159;
Ghast e = 2.71828;
Ghast resultado_flotante = 0.0;
Spider texto = "
Prueba
de
rendimiento
";
Spider resultado_texto = "
";
Rune caracter = 'A';
Torch condicion = On;
Shelf[ARRAY_SIZE] Stack numeros;
Shelf[ARRAY_SIZE] Ghast valores_reales;
Shelf[10] Spider textos = ["
uno
", "
dos
", "
tres
", "
cuatro
", "
cinco
", "
seis
", "
siete
", "
ocho
", "
nueve
", "
diez
"];
Chest conjunto_numeros = {: 1, 2, 3, 4, 5 :};
Chest conjunto_caracteres = {: 'a', 'b', 'c', 'd', 'e' :};
Book archivo_log = {/ "
log
.
txt
", 'E' /};
Book archivo_datos = {/ "
datos
.
dat
", 'L' /};
Entity Posicion origen
PolloCrudo
x: 0;
y: 0;
z: 0;
PolloAsado;
Entity Item espada
PolloCrudo
nombre: "
Espada
de
diamante
";
cantidad: 1;
durabilidad: 1000;
peso: 5.0;
consumible: Off;
PolloAsado;
Entity Jugador jugador_principal;
Entity Jugador jugadores[5];
Recipe
Spell calcularDanio(Stack :: nivel; Ghast :: multiplicador) -> Stack;
Spell distanciaEntre(Entity Posicion :: pos1, pos2) -> Ghast;
Spell crearItem(Spider :: nombre; Stack cantidad, durabilidad; Ghast peso; Torch consumible) -> Entity Item;
Ritual inicializarJugador(Entity Jugador ref jugador; Spider :: nombre; Stack nivel; Ghast salud);
Ritual mostrarEstadisticas(Entity Jugador :: jugador);
Ritual procesarInventario(Shelf[10] Entity Item :: inventario);
CraftingTable
Spell calcularDanio(Stack :: nivel; Ghast :: multiplicador) -> Stack
PolloCrudo
Stack danio_base = nivel * 2 + 5;
Stack danio_final = danio_base;
target nivel > 10 craft hit
PolloCrudo
danio_final += (nivel - 10) * 3;
PolloAsado
Ghast temp = danio_final >> Ghast;
temp = temp :* multiplicador;
danio_final = temp >> Stack;
respawn danio_final;
PolloAsado
Spell distanciaEntre(Entity Posicion :: pos1, pos2) -> Ghast
PolloCrudo
Stack dx = pos1@x - pos2@x;
Stack dy = pos1@y - pos2@y;
Stack dz = pos1@z - pos2@z;
Ghast dx_float = dx >> Ghast;
Ghast dy_float = dy >> Ghast;
Ghast dz_float = dz >> Ghast;
Ghast suma_cuadrados = (dx_float :* dx_float) :+ (dy_float :* dy_float) :+ (dz_float :* dz_float);
Ghast result = suma_cuadrados :// 2.0;
respawn result;
PolloAsado
Spell crearItem(Spider :: nombre; Stack cantidad, durabilidad; Ghast peso; Torch consumible) -> Entity Item
PolloCrudo
Entity Item nuevo_item
PolloCrudo
nombre: nombre;
cantidad: cantidad;
durabilidad: durabilidad;
peso: peso;
consumible: consumible;
PolloAsado;
respawn nuevo_item;
PolloAsado
Ritual inicializarJugador(Entity Jugador ref jugador; Spider :: nombre; Stack nivel; Ghast salud)
PolloCrudo
jugador@nombre = nombre;
jugador@nivel = nivel;
jugador@salud = salud;
jugador@posicion@x = 0;
jugador@posicion@y = 0;
jugador@posicion@z = 0;
walk i set 0 to 9 craft
PolloCrudo
jugador@inventario[i] = crearItem("
Item_
" bind i, i + 1, 100 * (i + 1), i :* 0.5, i % 2 is 0);
PolloAsado
PolloAsado
Ritual mostrarEstadisticas(Entity Jugador :: jugador)
PolloCrudo
dropperSpider("
==
=
Estadísticas
del
Jugador
==
=
");
dropperSpider("
Nombre
:
" bind jugador@nombre);
dropperSpider("
Nivel
:
" bind jugador@nivel);
dropperSpider("
Salud
:
" bind jugador@salud);
dropperSpider("
Posición
:
(
" bind jugador@posicion@x bind "
,
" bind jugador@posicion@y bind "
,
" bind jugador@posicion@z bind "
)
");
dropperSpider("
Inventario
:
" bind #(jugador@inventario) bind "
items
");
PolloAsado
Ritual procesarInventario(Shelf[10] Entity Item :: inventario)
PolloCrudo
Stack total_items = 0;
Ghast peso_total = 0.0;
Spider lista_items = "
";
walk i set 0 to 9 craft
PolloCrudo
total_items += inventario[i]@cantidad;
peso_total = peso_total :+ (inventario[i]@peso :* inventario[i]@cantidad >> Ghast);
target i < 9 craft hit
PolloCrudo
lista_items = lista_items bind inventario[i]@nombre bind "
,
";
PolloAsado
miss
PolloCrudo
lista_items = lista_items bind inventario[i]@nombre;
PolloAsado
PolloAsado
dropperSpider("
Total
items
:
" bind total_items);
dropperSpider("
Peso
total
:
" bind peso_total);
dropperSpider("
Lista
:
" bind lista_items);
PolloAsado
SpawnPoint
dropperSpider(TEST_NAME bind "
v
" bind VERSION);
walk i set 0 to ARRAY_SIZE - 1 craft
PolloCrudo
numeros[i] = (i * i + i) % MAX_VALUE;
valores_reales[i] = i :* PI :// 10.0;
target i < 20 craft hit
PolloCrudo
add(conjunto_numeros, i * 10);
PolloAsado
PolloAsado
jugador_principal@nombre = "
Aventurero
";
jugador_principal@nivel = 25;
jugador_principal@salud = 95.5;
jugador_principal@posicion@x = 100;
jugador_principal@posicion@y = 64;
jugador_principal@posicion@z = -50;
walk i set 0 to 4 craft
PolloCrudo
Spider nombre_jugador = "
Jugador_
" bind i;
Stack nivel_inicial = 1 + i * 5;
Ghast salud_inicial = 20.0 :+ (i :* 5.0);
ender_pearl inicializarJugador(jugadores[i], nombre_jugador, nivel_inicial, salud_inicial);
PolloAsado
dropperSpider("
Realizando
operaciones
mezcladas
.
.
.
");
contador = 0;
suma = 0;
producto = 1;
resultado_texto = "
";
walk iteracion set 0 to ITERATIONS - 1 craft
PolloCrudo
Stack indice = iteracion % ARRAY_SIZE;
suma += numeros[indice];
target producto < 1000000 craft hit
PolloCrudo
producto *= (indice + 1);
PolloAsado
Ghast valor_real = valores_reales[indice];
resultado_flotante = resultado_flotante :+ valor_real;
target resultado_flotante :> 1000.0 craft hit
PolloCrudo
resultado_flotante = resultado_flotante :% 1000.0;
PolloAsado
Spider texto_iteracion = textos[iteracion % 10];
target iteracion % 5 is 0 craft hit
PolloCrudo
resultado_texto = resultado_texto bind texto_iteracion;
PolloAsado
target iteracion % 2 is 0 craft hit
PolloCrudo
caracter = etchUp(caracter);
PolloAsado
miss
PolloCrudo
caracter = etchDown(caracter);
PolloAsado
condicion = condicion xor (iteracion % 3 is 0);
target indice % 2 is 0 and condicion craft hit
PolloCrudo
soulsand contador;
PolloAsado
target iteracion % 10 is 0 craft hit
PolloCrudo
Stack danio = calcularDanio(jugador_principal@nivel, 1.5);
Ghast distancia = distanciaEntre(jugador_principal@posicion, origen);
dropperSpider("
Iteración
" bind iteracion bind "
:
Daño
=
" bind danio bind "
,
Distancia
=
" bind distancia);
PolloAsado
Stack jugador_indice = iteracion % 5;
soulsand jugadores[jugador_indice]@nivel;
target iteracion % 20 is 0 craft hit
PolloCrudo
ender_pearl mostrarEstadisticas(jugadores[jugador_indice]);
PolloAsado
PolloAsado
dropperSpider("
Prueba
completada
.
Resultados
:
");
dropperSpider("
Suma
total
:
" bind suma);
dropperSpider("
Producto
acumulado
:
" bind producto);
dropperSpider("
Resultado
flotante
:
" bind resultado_flotante);
dropperSpider("
Texto
resultante
:
" bind resultado_texto);
dropperSpider("
Caracter
final
:
" bind caracter);
dropperSpider("
Contador
incrementado
:
" bind contador);
dropperSpider("
Estado
de
condición
final
:
" bind condicion);
ender_pearl procesarInventario(jugador_principal@inventario);
dropperSpider("
Prueba
de
rendimiento
con
tokens
variados
finalizada
");
worldSave
$*
Prueba_PR_Estructura.ne
Propósito: Verificar el reconocimiento de palabras reservadas de estructura del programa
Probar: WorldName, Bedrock, ResourcePack, Inventory, Recipe, CraftingTable, SpawnPoint
Fecha: 28/04/2025
*$
$$ Prueba de la estructura básica del programa NotchEngine
$$ Verificando las palabras reservadas: WorldName, Bedrock, ResourcePack, Inventory, Recipe, CraftingTable, SpawnPoint
WorldName PruebaEstructura:
Bedrock
Obsidian Stack MAX_VALOR 100;
Obsidian Spider SALUDO "
Prueba
de
estructura
";
ResourcePack
Anvil Stack -> Spider;
Inventory
Stack contador = 0;
Spider mensaje = "
Hola
mundo
";
Recipe
Spell sumar(Stack :: a, b) -> Stack;
Ritual mostrarMensaje(Spider :: texto);
CraftingTable
Spell sumar(Stack :: a, b) -> Stack
PolloCrudo
Stack resultado = a + b;
respawn resultado;
PolloAsado
Ritual mostrarMensaje(Spider :: texto)
PolloCrudo
dropperSpider(texto);
PolloAsado
SpawnPoint
PolloCrudo
dropperSpider(SALUDO);
Stack resultado = sumar(5, 10);
dropperSpider("
El
resultado
es
:
" bind resultado);
PolloAsado
worldSave
$*
Prueba_PR_Tipos.ne
Propósito: Verificar reconocimiento de tipos de datos en NotchEngine
Probar: Stack, Rune, Spider, Torch, Chest, Book, Ghast, Shelf, Entity
Fecha: 28/04/2025
*$
$$ Prueba de los tipos de datos en NotchEngine
$$ Verificando: Stack, Rune, Spider, Torch, Chest, Book, Ghast, Shelf, Entity
WorldName PruebaTipos:
Inventory
$$ Declaraciones de variables de cada tipo
$$ Stack - Tipo de dato entero
Stack entero = 42;
$$ Rune - Tipo de dato carácter
Rune caracter = 'N';
$$ Spider - Tipo de dato string
Spider texto = "
NotchEngine
";
$$ Torch - Tipo de dato booleano
Torch verdadero = On;
Torch falso = Off;
$$ Chest - Tipo de dato conjunto
Chest numeros = {: 1, 2, 3, 4, 5 :};
$$ Book - Tipo de dato archivo de texto
Book archivo = {/ "
datos
.
txt
", 'E' /};
$$ Ghast - Tipo de datos números flotantes
Ghast decimal = 3.14159;
$$ Shelf - Tipo de dato arreglos
Shelf[5] Stack arreglo = [1, 2, 3, 4, 5];
$$ Entity - Tipo de dato registros
Entity Jugador
PolloCrudo
Spider nombre;
Stack nivel;
Ghast salud;
PolloAsado;
Entity Jugador jugador = {nombre: "
Steve
", nivel: 1, salud: 20.0};
SpawnPoint
PolloCrudo
dropperSpider("
Prueba
de
tipos
completada
");
PolloAsado
worldSave
$*
Prueba_PR_Booleanos.ne
Propósito: Verificar reconocimiento de literales booleanas (On, Off)
Probar: Torch, And, Or, Not
Fecha: 28/04/2025
*$
$$ Prueba de literales booleanas en NotchEngine
$$ Verificando: On, Off
WorldName PruebaBooleanos:
Bedrock
Obsidian Torch VERDADERO On;
Obsidian Torch FALSO Off;
Inventory
$$ Declaración e inicialización con valores booleanos
Torch activo = On;
Torch inactivo = Off;
$$ Variables para almacenar resultados de operaciones lógicas
Torch resultado1;
Torch resultado2;
Torch resultado3;
Torch resultado4;
Torch resultado5;
SpawnPoint
PolloCrudo
$$ Mostrar valores booleanos directos
dropperSpider("
Valor
de
On
:
");
dropperTorch(On);
dropperSpider("
Valor
de
Off
:
");
dropperTorch(Off);
$$ Operaciones lógicas con literales booleanas
resultado1 = On and On;
dropperSpider("
On
and
On
:
");
dropperTorch(resultado1);
resultado2 = On and Off;
dropperSpider("
On
and
Off
:
");
dropperTorch(resultado2);
resultado3 = On or Off;
dropperSpider("
On
or
Off
:
");
dropperTorch(resultado3);
resultado4 = Off or Off;
dropperSpider("
Off
or
Off
:
");
dropperTorch(resultado4);
resultado5 = not On;
dropperSpider("
not
On
:
");
dropperTorch(resultado5);
$$ Uso en estructuras de control
target On craft hit
PolloCrudo
dropperSpider("
Condición
On
es
verdadera
");
PolloAsado
target Off craft hit
PolloCrudo
dropperSpider("
Esto
no
debería
mostrarse
");
PolloAsado
miss
PolloCrudo
dropperSpider("
Condición
Off
es
falsa
");
PolloAsado
PolloAsado
worldSave
$*
Prueba_PR_Bloques.ne
Propósito: Verificar reconocimiento de delimitadores de bloques (PolloCrudo, PolloAsado)
Probar: PolloCrudo, PolloAsado
Fecha: 28/04/2025
*$
$$ Prueba de delimitadores de bloques en NotchEngine
$$ Verificando: PolloCrudo, PolloAsado
WorldName PruebaBloques:
Inventory
$$ Variables para las pruebas
Stack contador = 0;
Stack acumulador = 0;
Stack resultado = 0;
Spider mensaje = "
Prueba
de
bloques
PolloCrudo
y
PolloAsado
";
CraftingTable
$$ Función con bloques de código
Spell sumarPares(Stack :: limite) -> Stack
PolloCrudo
Stack suma = 0;
$$ Bloque anidado dentro de una estructura de control
walk i set 1 to limite craft
PolloCrudo
target i % 2 is 0 craft hit
PolloCrudo
suma += i;
PolloAsado
PolloAsado
respawn suma;
PolloAsado
$$ Función con diferentes niveles de anidamiento de bloques
Spell calcularFactorial(Stack :: n) -> Stack
PolloCrudo
target n <= 1 craft hit
PolloCrudo
respawn 1;
PolloAsado
$$ Bloque dentro de una expresión
Stack resultado = n * calcularFactorial(n - 1);
respawn resultado;
PolloAsado
SpawnPoint
$$ Bloque principal
PolloCrudo
$$ Bloque simple
PolloCrudo
contador = 5;
dropperSpider(mensaje);
PolloAsado
$$ Bloque dentro de una estructura repeater
repeater contador > 0 craft
PolloCrudo
acumulador += contador;
magma contador;
$$ Bloque anidado dentro de un condicional dentro de un bucle
target contador is 2 craft hit
PolloCrudo
dropperSpider("
Contador
es
igual
a
2
");
$$ Otro bloque más anidado
PolloCrudo
dropperSpider("
Este
es
un
bloque
muy
anidado
");
PolloAsado
PolloAsado
PolloAsado
$$ Uso de bloques en estructura condicional
target acumulador > 10 craft hit
PolloCrudo
dropperSpider("
Acumulador
es
mayor
que
10
");
PolloAsado
miss
PolloCrudo
dropperSpider("
Acumulador
es
menor
o
igual
a
10
");
PolloAsado
$$ Bloque en estructura spawner-exhausted
spawner
PolloCrudo
soulsand resultado;
target resultado > 5 craft hit creeper;
PolloAsado
exhausted resultado > 10;
dropperSpider("
Valor
final
del
resultado
:
" bind resultado);
PolloAsado
worldSave
$*
Prueba_PR_Control.ne
Propósito: Verificar reconocimiento de palabras de control de flujo
Probar: Entity, PolloCrudo, PolloAsado, Punto, SpawnPoint, Inventory, WorldName
Fecha: 28/04/2025
*$
$$ Prueba de palabras reservadas de control de flujo en NotchEngine
$$ Verificando: repeater, craft, target, hit, miss, jukebox, disc, silence,
$$ spawner, exhausted, walk, set, to, step, wither
WorldName PruebaControl:
Inventory
$$ Variables para las pruebas
Stack contador = 0;
Stack opcion = 2;
Torch condicion = On;
Stack iterador = 0;
Entity Punto
PolloCrudo
Stack x;
Stack y;
PolloAsado;
Entity Punto coordenada;
SpawnPoint
PolloCrudo
$$ 1. Prueba de repeater (while) con craft
dropperSpider("
Prueba
de
repeater
:
");
contador = 5;
repeater contador > 0 craft
PolloCrudo
dropperStack(contador);
magma contador;
PolloAsado
$$ 2. Prueba de target (if) con hit y miss
dropperSpider("
Prueba
de
target
con
hit
y
miss
:
");
target condicion craft hit
PolloCrudo
dropperSpider("
Condición
es
verdadera
");
PolloAsado
miss
PolloCrudo
dropperSpider("
Condición
es
falsa
");
PolloAsado
$$ 3. Prueba de jukebox (switch) con disc y silence
dropperSpider("
Prueba
de
jukebox
con
disc
y
silence
:
");
jukebox opcion craft
disc 1:
PolloCrudo
dropperSpider("
Opción
1
seleccionada
");
PolloAsado
disc 2:
PolloCrudo
dropperSpider("
Opción
2
seleccionada
");
PolloAsado
silence:
PolloCrudo
dropperSpider("
Ninguna
opción
válida
seleccionada
");
PolloAsado
$$ 4. Prueba de spawner (do-while) con exhausted
dropperSpider("
Prueba
de
spawner
con
exhausted
:
");
contador = 0;
spawner
PolloCrudo
soulsand contador;
dropperStack(contador);
PolloAsado
exhausted contador >= 3;
$$ 5. Prueba de walk (for) con set, to, step
dropperSpider("
Prueba
de
walk
con
set
,
to
,
step
:
");
walk i set 0 to 10 step 2 craft
PolloCrudo
dropperStack(i);
PolloAsado
$$ 6. Prueba de wither (with)
dropperSpider("
Prueba
de
wither
:
");
coordenada@x = 10;
coordenada@y = 20;
wither coordenada craft
PolloCrudo
dropperSpider("
Coordenadas
:
(
" bind x bind "
,
" bind y bind "
)
");
PolloAsado
PolloAsado
worldSave
$*
Prueba_PR_Saltos.ne
Propósito: Verificar palabras para saltos y terminación (creeper, enderPearl, ragequit)
Fecha: 28/04/2025
*$
$$ Prueba de palabras reservadas para saltos y terminación en NotchEngine
$$ Verificando: creeper, enderPearl, ragequit
WorldName PruebaSaltos:
Inventory
$$ Variables para las pruebas
Stack contador = 0;
Stack totalPares = 0;
Stack totalImpares = 0;
Torch errorCritico = Off;
SpawnPoint
PolloCrudo
$$ 1. Prueba de creeper (break) para salir de un bucle
dropperSpider("
Prueba
de
creeper
(
break
)
:
");
walk i set 1 to 10 craft
PolloCrudo
dropperSpider("
Iteración
:
" bind i);
$$ Salimos del bucle cuando i llega a 5
target i is 5 craft hit
PolloCrudo
dropperSpider("
Encontrado
5
,
saliendo
del
bucle
con
creeper
");
creeper;
PolloAsado
PolloAsado
$$ 2. Prueba de enderPearl (continue) para saltar a la siguiente iteración
dropperSpider("
Prueba
de
enderPearl
(
continue
)
:
");
walk i set 1 to 10 craft
PolloCrudo
$$ Saltamos los números pares
target i % 2 is 0 craft hit
PolloCrudo
dropperSpider("
Número
par
" bind i bind "
,
saltando
con
enderPearl
");
enderPearl;
PolloAsado
$$ Esta parte solo se ejecuta para números impares
dropperSpider("
Procesando
número
impar
:
" bind i);
totalImpares += i;
PolloAsado
dropperSpider("
Total
de
números
impares
:
" bind totalImpares);
$$ 3. Prueba de creeper y enderPearl en bucles anidados
dropperSpider("
Prueba
de
control
de
flujo
en
bucles
anidados
:
");
walk i set 1 to 5 craft
PolloCrudo
walk j set 1 to 5 craft
PolloCrudo
$$ Saltar la iteración cuando j es 3
target j is 3 craft hit
PolloCrudo
dropperSpider("
Saltando
j
=
3
con
enderPearl
");
enderPearl;
PolloAsado
$$ Salir del bucle interno cuando j es 4
target j is 4 craft hit
PolloCrudo
dropperSpider("
Saliendo
del
bucle
interno
con
creeper
en
j
=
4
");
creeper;
PolloAsado
dropperSpider("
i
=
" bind i bind "
,
j
=
" bind j);
PolloAsado
PolloAsado
$$ 4. Prueba de ragequit (halt) para terminar el programa
$$ Nota: Esta parte debe estar comentada en pruebas reales
$$ o al final del programa, ya que detiene la ejecución
dropperSpider("
Prueba
de
ragequit
(
halt
)
:
");
target errorCritico craft hit
PolloCrudo
dropperSpider("
Error
crítico
detectado
,
terminando
programa
con
ragequit
");
$$ ragequit; $$ Comentado para evitar terminar la prueba
PolloAsado
dropperSpider("
Esta
línea
se
mostrará
si
errorCritico
es
Off
");
$$ Ejemplo descomentado pero que nunca se ejecutará
target Off craft hit
PolloCrudo
dropperSpider("
Esta
condición
nunca
se
cumple
");
ragequit;
PolloAsado
PolloAsado
worldSave
$*
Prueba_PR_Funciones.ne
Propósito: Verificar palabras para funciones y procedimientos (Spell, Ritual, respawn, ender_pearl)
Probar: Spell, Ritual, respawn, ender_pearl, crafting_table
Fecha: 28/04/2025
*$
$$ Prueba de palabras reservadas para funciones y procedimientos en NotchEngine
$$ Verificando: Spell, Ritual, respawn
WorldName PruebaFunciones:
$$ Sección de prototipos
Recipe
$$ Prototipos de funciones (Spell)
Spell sumar(Stack :: a, b) -> Stack;
Spell factorial(Stack :: n) -> Stack;
Spell esPar(Stack :: numero) -> Torch;
Spell sumarArreglo(Shelf[10] Stack :: numeros; Stack tamano) -> Stack;
$$ Prototipos de procedimientos (Ritual)
Ritual imprimirLinea(Spider :: texto);
Ritual mostrarResultado(Spider :: operacion; Stack valor);
Ritual imprimirArreglo(Shelf[10] Stack :: arr; Stack tamano);
$$ Sección de rutinas (implementación de funciones y procedimientos)
CraftingTable
$$ Funciones (Spell) con instrucción de retorno (respawn)
Spell sumar(Stack :: a, b) -> Stack
PolloCrudo
$$ Retorno con expresión simple
respawn a + b;
PolloAsado
Spell factorial(Stack :: n) -> Stack
PolloCrudo
$$ Retorno temprano con condición
target n <= 1 craft hit
PolloCrudo
respawn 1;
PolloAsado
$$ Retorno con expresión compleja y llamada recursiva
respawn n * factorial(n - 1);
PolloAsado
Spell esPar(Stack :: numero) -> Torch
PolloCrudo
target numero % 2 is 0 craft hit
PolloCrudo
respawn On;
PolloAsado
miss
PolloCrudo
respawn Off;
PolloAsado
PolloAsado
Spell sumarArreglo(Shelf[10] Stack :: numeros; Stack tamano) -> Stack
PolloCrudo
Stack suma = 0;
$$ Verificar parámetros
target tamano <= 0 craft hit
PolloCrudo
respawn 0; $$ Retorno temprano
PolloAsado
$$ Sumar elementos del arreglo
walk i set 0 to tamano - 1 craft
PolloCrudo
suma += numeros[i];
PolloAsado
respawn suma; $$ Retorno al final
PolloAsado
$$ Procedimientos (Ritual) con posibles retornos vacíos
Ritual imprimirLinea(Spider :: texto)
PolloCrudo
dropperSpider(texto);
dropperSpider("
--
--
--
--
--
--
--
--
--
--
--
--
");
PolloAsado
Ritual mostrarResultado(Spider :: operacion; Stack valor)
PolloCrudo
dropperSpider(operacion bind "
:
" bind valor);
$$ Retorno temprano sin valor
target valor < 0 craft hit
PolloCrudo
dropperSpider("
Valor
negativo
");
respawn; $$ Retorno vacío temprano
PolloAsado
dropperSpider("
Valor
válido
procesado
");
PolloAsado
Ritual imprimirArreglo(Shelf[10] Stack :: arr; Stack tamano)
PolloCrudo
target tamano <= 0 craft hit
PolloCrudo
dropperSpider("
Arreglo
vacío
");
respawn; $$ Retorno vacío temprano
PolloAsado
dropperSpider("
Elementos
del
arreglo
:
");
walk i set 0 to tamano - 1 craft
PolloCrudo
dropperStack(arr[i]);
PolloAsado
PolloAsado
$$ Punto de entrada con llamadas a funciones y procedimientos
SpawnPoint
PolloCrudo
$$ Declaración de variables
Stack a = 5;
Stack b = 7;
Stack resultado;
Shelf[10] Stack numeros;
$$ Inicializar arreglo
walk i set 0 to 9 craft
PolloCrudo
numeros[i] = i + 1;
PolloAsado
$$ Llamadas a funciones (invocación directa)
resultado = sumar(a, b);
dropperSpider("
Suma
:
" bind resultado);
resultado = factorial(5);
dropperSpider("
Factorial
de
5
:
" bind resultado);
Torch esPar5 = esPar(5);
dropperSpider("
Es
5
par
:
");
dropperTorch(esPar5);
resultado = sumarArreglo(numeros, 10);
dropperSpider("
Suma
del
arreglo
:
" bind resultado);
$$ Llamadas a procedimientos
imprimirLinea("
==
==
Resultados
de
pruebas
==
==
");
mostrarResultado("
Suma
de
5
y
7
", sumar(a, b));
mostrarResultado("
Valor
negativo
", -10);
imprimirArreglo(numeros, 5);
imprimirArreglo(numeros, 0);
PolloAsado
worldSave
$*
Prueba_PR_Operadores.ne
Propósito: Verificar operadores textuales reales en Notch Engine
Probar: soulsand, magma, and, or, not, xor, bind, #, from ##, except ##, seek,
add, drop, feed, map, biom, void, isEngraved, isInscribed, etchUp, etchDown,
unlock, lock, make, gather, forge, expand
Fecha: 28/04/2025
*$
WorldName PruebaOperadores:
Inventory {
Stack contador = 5; $$ Inicializa contador con 5
Torch condicion1 = On; $$ Condición 1 es verdadera
Torch condicion2 = Off; $$ Condición 2 es falsa
Torch resultado; $$ Variable para almacenar resultados booleanos
Spider texto1 = "
Notch
"; $$ Texto inicial "
Notch
"
Spider texto2 = "
Engine
"; $$ Texto inicial "
Engine
"
Spider textoCompleto; $$ Variable para texto combinado
Rune letra = 'a'; $$ Letra inicial 'a'
Rune letraMayuscula; $$ Variable para letra mayúscula
Chest conjunto1 = {: 1, 2, 3 :}; $$ Conjunto inicial con 1, 2, 3
Chest conjunto2 = {: 3, 4, 5 :}; $$ Conjunto inicial con 3, 4, 5
Chest conjuntoResultado; $$ Variable para resultado de conjuntos
Book archivo1 = {/ "
datos
.
txt
", 'E' /}; $$ Archivo para escritura "
datos
.
txt
"
Book archivo2 = {/ "
resultado
.
txt
", 'E' /}; $$ Archivo para escritura "
resultado
.
txt
"
Ghast flotante1 = 3.5; $$ Flotante inicial 3.5
Ghast flotante2 = 2.5; $$ Flotante inicial 2.5
Ghast resultadoFlotante; $$ Variable para resultado de operaciones flotantes
}
SpawnPoint {
PolloCrudo
$$ soulsand y magma
soulsand contador; $$ Aplica soulsand a contador
magma contador; $$ Aplica magma a contador
$$ and, or, not, xor
resultado = condicion1 and condicion2; $$ Resultado es verdadero si ambas condiciones son verdaderas
resultado = condicion1 or condicion2; $$ Resultado es verdadero si al menos una condición es verdadera
resultado = not condicion1; $$ Resultado es el opuesto de condicion1
resultado = condicion1 xor condicion2; $$ Resultado es verdadero si solo una condición es verdadera
$$ bind, #, from ##, except ##, seek
textoCompleto = bind(texto1, "
" bind texto2); $$ Combina texto1 y texto2 con un espacio
Stack longitud = #(textoCompleto); $$ Longitud de textoCompleto
Spider subcadena = from textoCompleto ## 0 ## 5; $$ Subcadena de textoCompleto desde 0 hasta 5
Spider sinNotch = except textoCompleto ## 0 ## 6; $$ Elimina caracteres de 0 a 6 en textoCompleto
Stack posicion = seek(textoCompleto, "
Engine
"); $$ Posición de "
Engine
" en textoCompleto
$$ isEngraved, isInscribed, etchUp, etchDown
Torch esLetra = isEngraved(letra); $$ Verifica si letra es una letra
Torch esDigito = isInscribed(letra); $$ Verifica si letra es un dígito
letraMayuscula = etchUp(letra); $$ Convierte letra a mayúscula
Rune letraMinuscula = etchDown(letraMayuscula); $$ Convierte letraMayuscula a minúscula
$$ Operaciones de conjuntos
add(conjunto1, 4); $$ Añade 4 a conjunto1
drop(conjunto1, 2); $$ Elimina 2 de conjunto1
conjuntoResultado = feed(conjunto1, conjunto2); $$ Intersección de conjunto1 y conjunto2
resultado = map(conjunto1, 3); $$ Verifica si 3 está en conjunto1
Torch conjuntoVacio = void(conjunto1); $$ Verifica si conjunto1 está vacío
$$ Operaciones de archivos
unlock(archivo1); $$ Abre archivo1 para escritura
forge(archivo1, "
Texto
de
prueba
"); $$ Escribe "
Texto
de
prueba
" en archivo1
lock(archivo1); $$ Cierra archivo1
Book nuevoArchivo = make({/ "
nuevo
.
txt
", 'E' /}); $$ Crea nuevo archivo "
nuevo
.
txt
"
forge(nuevoArchivo, "
Contenido
del
nuevo
archivo
"); $$ Escribe en nuevoArchivo
lock(nuevoArchivo); $$ Cierra nuevoArchivo
unlock(archivo1); $$ Abre archivo1
unlock(nuevoArchivo); $$ Abre nuevoArchivo
expand(archivo1, nuevoArchivo); $$ Expande archivo1 con contenido de nuevoArchivo
lock(archivo1); $$ Cierra archivo1
lock(nuevoArchivo); $$ Cierra nuevoArchivo
$$ Operadores de flotantes
resultadoFlotante = flotante1 :+ flotante2; $$ Suma de flotante1 y flotante2
resultadoFlotante = flotante1 :- flotante2; $$ Resta de flotante1 y flotante2
resultadoFlotante = flotante1 :* flotante2; $$ Multiplicación de flotante1 y flotante2
resultadoFlotante = flotante1 :// flotante2; $$ División de flotante1 y flotante2
resultadoFlotante = flotante1 :% flotante2; $$ Módulo de flotante1 y flotante2
PolloAsado
}
worldSave
$*
Prueba_Lit_Enteros.ne
Propósito: Verificar reconocimiento de literales enteros (positivos, negativos, cero)
Probar: Stack
Fecha: 28/04/2025
*$
$$ Prueba de literales enteros en NotchEngine
$$ Verificando: enteros positivos, negativos y cero
WorldName PruebaLitEnteros:
Bedrock
$$ Constantes enteras
Obsidian Stack CERO 0;
Obsidian Stack POSITIVO 42;
Obsidian Stack NEGATIVO -42;
Obsidian Stack MAX_VALOR 2147483647; $$ Valor máximo de 32 bits
Obsidian Stack MIN_VALOR -2147483648; $$ Valor mínimo de 32 bits
Inventory
$$ Variables con literales enteros
Stack cero = 0;
Stack uno = 1;
Stack diez = 10;
Stack cien = 100;
Stack mil = 1000;
Stack millon = 1000000;
$$ Enteros negativos
Stack negUno = -1;
Stack negDiez = -10;
Stack negCien = -100;
Stack negMil = -1000;
Stack negMillon = -1000000;
$$ Valor entero máximo y mínimo (aproximadamente)
Stack maxInt = 2147483647;
Stack minInt = -2147483648;
$$ Variables para resultados
Stack resultado = 0;
SpawnPoint
PolloCrudo
$$ Operaciones aritméticas con literales enteros directos
resultado = 5 + 3; $$ 8
dropperSpider("
5
+
3
=
" bind resultado);
resultado = 10 - 7; $$ 3
dropperSpider("
10
-
7
=
" bind resultado);
resultado = 6 * 4; $$ 24
dropperSpider("
6
*
4
=
" bind resultado);
resultado = 20 // 4; $$ 5
dropperSpider("
20
4
=
" bind resultado);
resultado = 17 % 5; $$ 2
dropperSpider("
17
%
5
=
" bind resultado);
$$ Uso de literales enteros en expresiones complejas
resultado = (5 + 3) * 2 - 4 // 2; $$ 16 - 2 = 14
dropperSpider("
(
5
+
3
)
*
2
-
4
2
=
" bind resultado);
$$ Operaciones con literales enteros negativos
resultado = -5 + 10; $$ 5
dropperSpider("
-
5
+
10
=
" bind resultado);
resultado = 5 + -10; $$ -5
dropperSpider("
5
+
-
10
=
" bind resultado);
resultado = -5 * -4; $$ 20
dropperSpider("
-
5
*
-
4
=
" bind resultado);
$$ Uso de literales enteros en estructuras de control
walk i set 1 to 5 craft
PolloCrudo
dropperSpider("
Iteración
:
" bind i);
PolloAsado
$$ Comparaciones con literales enteros
target 10 > 5 craft hit
PolloCrudo
dropperSpider("
10
es
mayor
que
5
");
PolloAsado
target 0 is 0 craft hit
PolloCrudo
dropperSpider("
0
es
igual
a
0
");
PolloAsado
target -10 < -5 craft hit
PolloCrudo
dropperSpider("
-
10
es
menor
que
-
5
");
PolloAsado
$$ Operaciones con valores extremos (cuidado con overflow)
dropperSpider("
Valor
máximo
de
entero
:
" bind maxInt);
dropperSpider("
Valor
mínimo
de
entero
:
" bind minInt);
$$ Verificación del cero
target 0 is cero craft hit
PolloCrudo
dropperSpider("
Ambas
representaciones
de
cero
son
iguales
");
PolloAsado
PolloAsado
worldSave
$*
Prueba_Lit_Flotantes.ne
Propósito: Verificar reconocimiento de números flotantes (con parte decimal, sin parte decimal, negativos)
Probar: Ghast
Fecha: 28/04/2025
*$
$$ Prueba de literales flotantes en NotchEngine
$$ Verificando: flotantes con parte decimal, sin parte decimal, y negativos
WorldName PruebaLitFlotantes:
Bedrock
$$ Constantes flotantes
Obsidian Ghast CERO_PUNTO_CERO 0.0;
Obsidian Ghast PI 3.14159;
Obsidian Ghast E 2.71828;
Obsidian Ghast NEG_PI -3.14159;
Obsidian Ghast GRAVEDAD -9.8;
Inventory
$$ Flotantes positivos con parte decimal
Ghast decimal1 = 0.5;
Ghast decimal2 = 1.25;
Ghast decimal3 = 3.14159;
Ghast decimal4 = 2.71828;
Ghast decimal5 = 123.456;
$$ Flotantes negativos con parte decimal
Ghast negDecimal1 = -0.5;
Ghast negDecimal2 = -1.25;
Ghast negDecimal3 = -3.14159;
Ghast negDecimal4 = -2.71828;
Ghast negDecimal5 = -123.456;
$$ Formas alternativas (punto al principio, sin parte decimal)
Ghast decimal6 = .5; $$ Sin cero al principio, comienza con punto
Ghast decimal7 = 5.; $$ Sin decimales, termina con punto
$$ Números con muchos decimales
Ghast precisionAlta = 1.123456789012345;
$$ Números muy pequeños y muy grandes
Ghast muyPequeno = 0.0000001;
Ghast muyGrande = 1000000.0;
$$ Variables para resultados
Ghast resultado = 0.0;
SpawnPoint
PolloCrudo
$$ Operaciones aritméticas con literales flotantes directos
resultado = 5.5 :+ 3.5; $$ 9.0
dropperSpider("
5.5
:
+
3.5
=
");
dropperGhast(resultado);
resultado = 10.75 :- 7.25; $$ 3.5
dropperSpider("
10.75
:
-
7.25
=
");
dropperGhast(resultado);
resultado = 6.5 :* 2.0; $$ 13.0
dropperSpider("
6.5
:
*
2.0
=
");
dropperGhast(resultado);
resultado = 20.0 :// 4.0; $$ 5.0
dropperSpider("
20.0
:
4.0
=
");
dropperGhast(resultado);
resultado = 7.5 :% 2.0; $$ 1.5
dropperSpider("
7.5
:
%
2.0
=
");
dropperGhast(resultado);
$$ Uso de notaciones decimales alternativas
resultado = .5 :+ 2.; $$ 0.5 + 2.0 = 2.5
dropperSpider("
.
5
:
+
2
.
=
");
dropperGhast(resultado);
$$ Operaciones con literales flotantes negativos
resultado = -5.5 :+ 10.0; $$ 4.5
dropperSpider("
-
5.5
:
+
10.0
=
");
dropperGhast(resultado);
resultado = 5.0 :+ -10.0; $$ -5.0
dropperSpider("
5.0
:
+
-
10.0
=
");
dropperGhast(resultado);
resultado = -5.0 :* -4.0; $$ 20.0
dropperSpider("
-
5.0
:
*
-
4.0
=
");
dropperGhast(resultado);
$$ Expresiones complejas con flotantes
resultado = (2.5 :+ 1.5) :* 3.0 :- 5.0 :// 2.0; $$ 12.0 - 2.5 = 9.5
dropperSpider("
(
2.5
:
+
1.5
)
:
*
3.0
:
-
5.0
:
2.0
=
");
dropperGhast(resultado);
$$ Comparaciones con flotantes
target 3.14 > 3.0 craft hit
PolloCrudo
dropperSpider("
3.14
es
mayor
que
3.0
");
PolloAsado
target 0.1 :+ 0.2 isNot 0.3 craft hit $$ Debido a errores de precisión en flotantes
PolloCrudo
dropperSpider("
0.1
+
0.2
no
es
exactamente
igual
a
0.3
(
error
de
precisión
)
");
dropperGhast(0.1 :+ 0.2);
PolloAsado
$$ Conversión y coherción de tipos
Stack entero = 3.14159 >> Stack; $$ Cohersión a entero (trunca a 3)
dropperSpider("
PI
truncado
a
entero
:
" bind entero);
$$ Mostrar valores con diferentes precisiones
dropperSpider("
Valor
de
PI
:
");
dropperGhast(PI);
dropperSpider("
Número
con
alta
precisión
:
");
dropperGhast(precisionAlta);
dropperSpider("
Número
muy
pequeño
:
");
dropperGhast(muyPequeno);
dropperSpider("
Número
muy
grande
:
");
dropperGhast(muyGrande);
PolloAsado
worldSave
$*
Prueba_Lit_Caracteres.ne
Propósito: Verificar reconocimiento de caracteres (letras, dígitos, símbolos, escapes)
Probar: Rune, dropperRune, dropperSpider, dropperTorch
Fecha: 28/04/2025
*$
$$ Prueba de literales de caracteres en NotchEngine
$$ Verificando: letras, dígitos, símbolos y secuencias de escape
WorldName PruebaLitCaracteres:
Bedrock
$$ Constantes de caracteres
Obsidian Rune LETRA_A 'A';
Obsidian Rune LETRA_Z 'Z';
Obsidian Rune DIGITO_0 '0';
Obsidian Rune DIGITO_9 '9';
Obsidian Rune NUEVA_LINEA '\n';
Obsidian Rune TABULACION '\t';
Inventory
$$ Letras mayúsculas
Rune letraA = 'A';
Rune letraB = 'B';
Rune letraC = 'C';
Rune letraZ = 'Z';
$$ Letras minúsculas
Rune letraMina = 'a';
Rune letraMinb = 'b';
Rune letraMinc = 'c';
Rune letraMinz = 'z';
$$ Dígitos
Rune digito0 = '0';
Rune digito1 = '1';
Rune digito5 = '5';
Rune digito9 = '9';
$$ Símbolos comunes
Rune simboloExclamacion = '!';
Rune simboloInterrogacion = '?';
Rune simboloArroba = '@';
Rune simboloNumeral = '#';
Rune simboloDolar = '$';
Rune simboloPorcentaje = '%';
Rune simboloAmpersand = '&';
Rune simboloAsterisco = '*';
Rune simboloParentesisIzq = '(';
Rune simboloParentesisDer = ')';
Rune simboloGuion = '-';
Rune simboloGuionBajo = '_';
Rune simboloIgual = '=';
Rune simboloMas = '+';
Rune simboloCorcheteIzq = '[';
Rune simboloCorcheteDer = ']';
Rune simboloLlaveIzq = '{';
Rune simboloLlaveDer = '}';
Rune simboloPuntoyComa = ';';
Rune simboloDosPuntos = ':';
Rune simboloComillaSimple = '\'';
Rune simboloComillaDoble = '"
';
Rune simboloBarra = '
';
Rune simboloBarraInversa = '
';
Rune simboloBarraVertical = '
';
Rune simboloComa = '
,
';
Rune simboloPunto = '
.
';
Rune simboloMenorQue = '
<
';
Rune simboloMayorQue = '
>
';
$$ Secuencias de escape
Rune escapeNuevaLinea = '
n
';
Rune escapeTabulacion = '
t
';
Rune escapeRetornoCarro = '
r
';
Rune escapeBarraInversa = '
';
Rune escapeComillaSimple = '
''
;
Rune
escapeComillaDoble
=
'\"'
;
SpawnPoint
PolloCrudo
dropperSpider
(
"Letras mayúsculas: "
)
;
dropperRune
(
letraA
)
;
dropperRune
(
letraB
)
;
dropperRune
(
letraC
)
;
dropperSpider
(
"Letras minúsculas: "
)
;
dropperRune
(
letraMina
)
;
dropperRune
(
letraMinb
)
;
dropperRune
(
letraMinc
)
;
dropperSpider
(
"Dígitos: "
)
;
dropperRune
(
digito0
)
;
dropperRune
(
digito1
)
;
dropperRune
(
digito5
)
;
dropperRune
(
digito9
)
;
dropperSpider
(
"Símbolos: "
)
;
dropperRune
(
simboloExclamacion
)
;
dropperRune
(
simboloInterrogacion
)
;
dropperRune
(
simboloArroba
)
;
dropperRune
(
simboloNumeral
)
;
Spider
texto
=
"NotchEngine"
;
Rune
primerCaracter
=
texto
[
0
]
;
Rune
ultimoCaracter
=
texto
[
10
]
;
dropperSpider
(
"Primer carácter de 'NotchEngine': "
)
;
dropperRune
(
primerCaracter
)
;
dropperSpider
(
"Último carácter de 'NotchEngine': "
)
;
dropperRune
(
ultimoCaracter
)
;
Rune
letraMinuscula
=
'a'
;
Rune
letraMayuscula
=
etchUp
(
letraMinuscula
)
;
dropperSpider
(
"Minúscula: "
)
;
dropperRune
(
letraMinuscula
)
;
dropperSpider
(
"Convertida a mayúscula: "
)
;
dropperRune
(
letraMayuscula
)
;
letraMinuscula
=
etchDown
(
letraMayuscula
)
;
dropperSpider
(
"Convertida nuevamente a minúscula: "
)
;
dropperRune
(
letraMinuscula
)
;
Torch
esLetra
=
isEngraved
(
'A'
)
;
Torch
esDigito
=
isInscribed
(
'5'
)
;
dropperSpider
(
"¿'A' es una letra? "
)
;
dropperTorch
(
esLetra
)
;
dropperSpider
(
"¿'5' es un dígito? "
)
;
dropperTorch
(
esDigito
)
;
esLetra
=
isEngraved
(
'7'
)
;
esDigito
=
isInscribed
(
'K'
)
;
dropperSpider
(
"¿'7' es una letra? "
)
;
dropperTorch
(
esLetra
)
;
dropperSpider
(
"¿'K' es un dígito? "
)
;
dropperTorch
(
esDigito
)
;
Stack
valorAsciiA
=
letraA
>
>
Stack
;
dropperSpider
(
"Valor ASCII de 'A': "
bind
valorAsciiA
)
;
PolloAsado
worldSave
WorldName
PruebaLitStrings
:
Bedrock
Obsidian
Spider
VACIO
""
;
Obsidian
Spider
ESPACIO
" "
;
Obsidian
Spider
SALUDO
"Hola Mundo"
;
Obsidian
Spider
CON_COMILLAS
"Este string tiene \"comillas\""
;
Obsidian
Spider
MULTILINEA
"Primera línea\nSegunda línea"
;
Inventory
Spider
cadenaVacia
=
""
;
Spider
espacioSimple
=
" "
;
Spider
cadenaSimple
=
"Texto simple"
;
Spider
conNumeros
=
"Notch Engine v1.0"
;
Spider
conSimbolos
=
"¡Hola, mundo! ¿Cómo estás?"
;
Spider
conCaracteresEspeciales
=
"#$%&/()=?¡"
;
Spider
conNuevaLinea
=
"Primera línea\nSegunda línea"
;
Spider
conTabulacion
=
"Columna1\tColumna2\tColumna3"
;
Spider
conRetornoCarro
=
"Texto con\rretorno de carro"
;
Spider
conBarraInversa
=
"Ruta de archivo: C:\\Archivos\\datos.txt"
;
Spider
conComillasSimples
=
"Texto con 'comillas simples'"
;
Spider
conComillasDobles
=
"Texto con \"comillas dobles\""
;
Spider
mixto
=
"Abc123!@#\n\t\"'"
;
Spider
cadenaLarga
=
"Esta es una cadena de texto más larga que contiene múltiples palabras, números como 12345, y símbolos como $%&. Es útil para probar el manejo de cadenas extensas en el analizador léxico y asegurarse de que no hay limitaciones inesperadas en la longitud de las cadenas."
;
Spider
prefijo
=
"Notch"
;
Spider
sufijo
=
"Engine"
;
Spider
resultado
;
SpawnPoint
PolloCrudo
dropperSpider
(
"Cadena simple: "
bind
cadenaSimple
)
;
dropperSpider
(
"Cadena con números: "
bind
conNumeros
)
;
dropperSpider
(
"Cadena con símbolos: "
bind
conSimbolos
)
;
resultado
=
bind
(
prefijo
,
" "
bind
sufijo
)
;
dropperSpider
(
"Concatenación: "
bind
resultado
)
;
Stack
longitud
=
#
(
resultado
)
;
dropperSpider
(
"Longitud de '"
bind
resultado
bind
"': "
bind
longitud
)
;
Spider
subcadena
=
from
resultado
#
#
0
#
#
5
;
dropperSpider
(
"Subcadena (0, 5): "
bind
subcadena
)
;
Spider
sinNotch
=
except
resultado
#
#
0
#
#
6
;
dropperSpider
(
"Sin los primeros 6 caracteres: "
bind
sinNotch
)
;
Stack
posicion
=
seek
(
resultado
,
"Engine"
)
;
dropperSpider
(
"Posición de 'Engine': "
bind
posicion
)
;
Rune
primerCaracter
=
resultado
[
0
]
;
dropperSpider
(
"Primer carácter: "
)
;
dropperRune
(
primerCaracter
)
;
Rune
ultimoCaracter
=
resultado
[
11
]
;
dropperSpider
(
"Último carácter: "
)
;
dropperRune
(
ultimoCaracter
)
;
dropperSpider
(
"Cadena con nueva línea:"
)
;
dropperSpider
(
conNuevaLinea
)
;
dropperSpider
(
"Cadena con tabulaciones:"
)
;
dropperSpider
(
conTabulacion
)
;
dropperSpider
(
"Cadena con comillas dobles:"
)
;
dropperSpider
(
conComillasDobles
)
;
dropperSpider
(
"Cadena larga:"
)
;
dropperSpider
(
cadenaLarga
)
;
target
cadenaVacia
is
""
craft
hit
PolloCrudo
dropperSpider
(
"La cadena está vacía"
)
;
PolloAsado
target
SALUDO
is
"Hola Mundo"
craft
hit
PolloCrudo
dropperSpider
(
"Las cadenas son iguales"
)
;
PolloAsado
PolloAsado
worldSave
WorldName
PruebaLitArreglos
:
Bedrock
Inventory
Shelf
[
5
]
Stack
numerosSimples
=
[
1
,
2
,
3
,
4
,
5
]
;
Shelf
[
3
]
Stack
numerosNegativos
=
[
-
10
,
-
20
,
-
30
]
;
Shelf
[
4
]
Stack
numerosMixtos
=
[
-
2
,
0
,
2
,
4
]
;
Shelf
[
1
]
Stack
unicoElemento
=
[
42
]
;
Shelf
[
0
]
Stack
arregloVacio
=
[
]
;
Shelf
[
5
]
Rune
vocales
=
[
'a'
,
'e'
,
'i'
,
'o'
,
'u'
]
;
Shelf
[
5
]
Rune
simbolos
=
[
'!'
,
'@'
,
'#'
,
'$'
,
'%'
]
;
Shelf
[
3
]
Spider
nombres
=
[
"Steve"
,
"Alex"
,
"Herobrine"
]
;
Shelf
[
4
]
Spider
diasSemana
=
[
"Lunes"
,
"Martes"
,
"Miércoles"
,
"Jueves"
]
;
Shelf
[
4
]
Torch
flags
=
[
On
,
Off
,
On
,
On
]
;
Shelf
[
3
]
Ghast
decimales
=
[
3.14
,
2.71
,
1.618
]
;
Shelf
[
3
]
Shelf
[
3
]
Stack
matriz
=
[
[
1
,
2
,
3
]
,
[
4
,
5
,
6
]
,
[
7
,
8
,
9
]
]
;
Shelf
[
2
]
Shelf
[
2
]
Shelf
[
2
]
Stack
cubo
=
[
[
[
1
,
2
]
,
[
3
,
4
]
]
,
[
[
5
,
6
]
,
[
7
,
8
]
]
]
;
Stack
suma
=
0
;
Stack
elementoActual
=
0
;
SpawnPoint
PolloCrudo
elementoActual
=
numerosSimples
[
0
]
;
dropperSpider
(
"Primer elemento del arreglo: "
bind
elementoActual
)
;
elementoActual
=
numerosSimples
[
4
]
;
dropperSpider
(
"Último elemento del arreglo: "
bind
elementoActual
)
;
numerosSimples
[
2
]
=
30
;
dropperSpider
(
"Elemento modificado: "
bind
numerosSimples
[
2
]
)
;
suma
=
0
;
walk
i
set
0
to
4
craft
PolloCrudo
suma
+
=
numerosSimples
[
i
]
;
dropperSpider
(
"Elemento "
bind
i
bind
": "
bind
numerosSimples
[
i
]
)
;
PolloAsado
dropperSpider
(
"Suma de todos los elementos: "
bind
suma
)
;
dropperSpider
(
"Vocales: "
)
;
walk
i
set
0
to
4
craft
PolloCrudo
dropperRune
(
vocales
[
i
]
)
;
PolloAsado
dropperSpider
(
"Nombres: "
)
;
walk
i
set
0
to
2
craft
PolloCrudo
dropperSpider
(
nombres
[
i
]
)
;
PolloAsado
dropperSpider
(
"Flags: "
)
;
walk
i
set
0
to
3
craft
PolloCrudo
dropperTorch
(
flags
[
i
]
)
;
PolloAsado
dropperSpider
(
"Decimales: "
)
;
walk
i
set
0
to
2
craft
PolloCrudo
dropperGhast
(
decimales
[
i
]
)
;
PolloAsado
elementoActual
=
matriz
[
1
]
[
1
]
;
dropperSpider
(
"Elemento central de la matriz: "
bind
elementoActual
)
;
matriz
[
0
]
[
2
]
=
10
;
dropperSpider
(
"Elemento modificado de la matriz: "
bind
matriz
[
0
]
[
2
]
)
;
dropperSpider
(
"Matriz completa:"
)
;
walk
i
set
0
to
2
craft
PolloCrudo
walk
j
set
0
to
2
craft
PolloCrudo
dropperStack
(
matriz
[
i
]
[
j
]
)
;
PolloAsado
dropperSpider
(
""
)
;
PolloAsado
elementoActual
=
cubo
[
1
]
[
0
]
[
1
]
;
dropperSpider
(
"Elemento de cubo [1][0][1]: "
bind
elementoActual
)
;
Shelf
[
4
]
Stack
fibonacci
=
[
1
,
1
,
2
,
3
]
;
dropperSpider
(
"Fibonacci: "
)
;
walk
i
set
0
to
3
craft
PolloCrudo
dropperStack
(
fibonacci
[
i
]
)
;
PolloAsado
PolloAsado
worldSave
WorldName
PruebaLitRegistros
:
Inventory
Entity
Jugador
PolloCrudo
Spider
nombre
;
Stack
nivel
;
Ghast
salud
;
Torch
activo
;
PolloAsado
;
Entity
Coordenada
PolloCrudo
Stack
x
;
Stack
y
;
Stack
z
;
PolloAsado
;
Entity
Configuracion
PolloCrudo
Torch
modoDebug
;
Stack
volumen
;
Spider
idioma
;
PolloAsado
;
Entity
Jugador
steve
=
{
nombre
:
"Steve"
,
nivel
:
1
,
salud
:
20.0
,
activo
:
On
}
;
Entity
Jugador
alex
=
{
nombre
:
"Alex"
,
nivel
:
2
,
salud
:
18.5
,
activo
:
On
}
;
Entity
Coordenada
posicion
=
{
x
:
10
,
y
:
20
,
z
:
30
}
;
Entity
Configuracion
config
=
{
modoDebug
:
Off
,
volumen
:
75
,
idioma
:
"Español"
}
;
Entity
Jugador
jugadorVacio
=
{
}
;
Entity
Coordenada
origen
=
{
x
:
0
}
;
Entity
Coordenada
punto
=
{
x
:
5
+
5
,
y
:
10
*
2
,
z
:
100
2
}
;
SpawnPoint
PolloCrudo
dropperSpider
(
steve
@
nombre
)
;
dropperStack
(
posicion
@
x
)
;
dropperTorch
(
config
@
modoDebug
)
;
steve
@
nivel
=
5
;
posicion
@
z
=
50
;
Stack
nivelTotal
=
steve
@
nivel
+
alex
@
nivel
;
dropperStack
(
nivelTotal
)
;
wither
steve
craft
PolloCrudo
dropperSpider
(
"Nombre: "
bind
nombre
)
;
dropperStack
(
nivel
)
;
dropperGhast
(
salud
)
;
PolloAsado
Entity
Jugador
herobrine
=
{
nombre
:
"Herobrine"
,
nivel
:
100
,
salud
:
1000.0
,
activo
:
On
}
;
Entity
Coordenada
pos2
=
{
x
:
100
,
y
:
200
,
z
:
300
}
;
PolloAsado
worldSave
WorldName
PruebaLitConjuntos
:
Inventory
Chest
numeros
=
{
:
1
,
2
,
3
,
4
,
5
:
}
;
Chest
primos
=
{
:
2
,
3
,
5
,
7
,
11
,
13
,
17
,
19
:
}
;
Chest
pares
=
{
:
2
,
4
,
6
,
8
,
10
:
}
;
Chest
vocales
=
{
:
'a'
,
'e'
,
'i'
,
'o'
,
'u'
:
}
;
Chest
consonantes
=
{
:
'b'
,
'c'
,
'd'
,
'f'
,
'g'
:
}
;
Chest
nombres
=
{
:
"Steve"
,
"Alex"
,
"Herobrine"
,
"Notch"
:
}
;
Chest
herramientas
=
{
:
"Espada"
,
"Pico"
,
"Hacha"
,
"Pala"
:
}
;
Chest
vacio
=
{
:
:
}
;
Chest
singleton
=
{
:
42
:
}
;
Chest
mezcla
=
{
:
1
,
'a'
,
"texto"
:
}
;
Chest
calculados
=
{
:
1
+
1
,
2
*
2
,
10
2
:
}
;
Chest
booleanos
=
{
:
On
,
Off
:
}
;
SpawnPoint
PolloCrudo
add
(
numeros
,
6
)
;
dropperSpider
(
"Después de add(numeros, 6):"
)
;
drop
(
primos
,
2
)
;
dropperSpider
(
"Después de drop(primos, 2):"
)
;
Chest
union
=
feed
(
numeros
,
primos
)
;
dropperSpider
(
"Unión de numeros y primos:"
)
;
Chest
interseccion
=
map
(
numeros
,
pares
)
;
dropperSpider
(
"Intersección de numeros y pares:"
)
;
Torch
contiene
=
biom
(
vocales
,
'a'
)
;
dropperTorch
(
contiene
)
;
Torch
esVacio
=
void
(
vacio
)
;
dropperTorch
(
esVacio
)
;
Chest
conEspacios
=
{
:
'a'
,
'b'
,
'c'
:
}
;
Chest
conComentarios
=
{
:
1
,
2
,
3
:
}
;
Chest
{
:
1
,
'x'
,
"y"
:
}
;
PolloAsado
worldSave
WorldName
PruebaLitArchivos
:
Inventory
Book
archivoConfiguracion
=
{
"config.txt"
,
'L'
}
;
Book
archivoJugadores
=
{
"jugadores.dat"
,
'L'
}
;
Book
archivoNiveles
=
{
"niveles/nivel1.map"
,
'L'
}
;
Book
archivoLog
=
{
"sistema.log"
,
'E'
}
;
Book
archivoResultados
=
{
"resultados.txt"
,
'E'
}
;
Book
archivoExportacion
=
{
"export/datos.csv"
,
'E'
}
;
Book
archivoPuntajes
=
{
"puntajes.dat"
,
'A'
}
;
Book
archivoInventario
=
{
"inventario.sav"
,
'A'
}
;
Book
archivoEspecial
=
{
"archivo con espacios.txt"
,
'L'
}
;
Book
archivoEspecial2
=
{
"datos_especiales-2023.dat"
,
'E'
}
;
Book
archivoRutaRelativa
=
{
"../datos/config.ini"
,
'L'
}
;
Book
archivoRutaAbsoluta
=
{
"C:/Notch/Engine/data.bin"
,
'E'
}
;
Book
archivoTexto
=
{
"readme.txt"
,
'L'
}
;
Book
archivoImagen
=
{
"textura.png"
,
'L'
}
;
Book
archivoJSON
=
{
"settings.json"
,
'A'
}
;
Book
archivoXML
=
{
"estructura.xml"
,
'A'
}
;
Book
conBarras
=
{
"dir/subdir/archivo.ext"
,
'L'
}
;
Book
conPuntos
=
{
"../../archivo.ext"
,
'E'
}
;
Book
espaciado1
=
{
"compacto.txt"
,
'L'
}
;
Book
espaciado2
=
{
"espacios.txt"
,
'E'
}
;
Book
comentado
=
{
"log.txt"
,
'L'
}
;
SpawnPoint
PolloCrudo
unlock
(
archivoLog
)
;
forge
(
archivoLog
,
"Entrada de log: Inicio de programa"
)
;
lock
(
archivoLog
)
;
Book
nuevoArchivo
=
make
(
{
"nuevo.txt"
,
'E'
}
)
;
unlock
(
archivoConfiguracion
)
;
Spider
contenido
=
gather
(
archivoConfiguracion
)
;
lock
(
archivoConfiguracion
)
;
expand
(
archivoLog
,
archivoResultados
)
;
Book
{
"sinVariable.txt"
,
'A'
}
;
Book
arch1
=
{
"uno.txt"
,
'L'
}
;
Book
arch2
=
{
"dos.txt"
,
'E'
}
;
Book
conComentarioMedio
=
{
"comentado.txt"
,
'A'
}
;
PolloAsado
worldSave
WorldName
PruebaOpAritmeticos
:
Inventory
Stack
a
=
10
;
Stack
b
=
3
;
Stack
c
;
Stack
resultado
;
SpawnPoint
PolloCrudo
c
=
a
+
b
;
dropperSpider
(
"Suma: "
bind
c
)
;
c
=
a
-
b
;
dropperSpider
(
"Resta: "
bind
c
)
;
c
=
a
*
b
;
dropperSpider
(
"Multiplicación: "
bind
c
)
;
c
=
a
b
;
dropperSpider
(
"División entera: "
bind
c
)
;
c
=
a
%
b
;
dropperSpider
(
"Módulo: "
bind
c
)
;
resultado
=
a
+
b
*
c
;
dropperSpider
(
"a + b * c = "
bind
resultado
)
;
resultado
=
(
a
+
b
)
*
c
;
dropperSpider
(
"(a + b) * c = "
bind
resultado
)
;
resultado
=
a
+
b
+
c
;
dropperSpider
(
"a + b + c = "
bind
resultado
)
;
resultado
=
a
*
b
c
+
a
-
b
;
dropperSpider
(
"a * b // c + a - b = "
bind
resultado
)
;
resultado
=
-
a
;
dropperSpider
(
"-a = "
bind
resultado
)
;
resultado
=
5
+
3
;
dropperSpider
(
"5 + 3 = "
bind
resultado
)
;
resultado
=
-
(
a
+
b
)
;
dropperSpider
(
"-(a + b) = "
bind
resultado
)
;
resultado
=
a
+
b
;
resultado
=
a
-
b
;
resultado
=
a
*
b
;
resultado
=
a
b
;
resultado
=
a
%
b
;
resultado
=
a
+
b
;
resultado
=
a
-
b
;
resultado
=
a
*
b
;
resultado
=
a
b
;
resultado
=
a
%
b
;
resultado
=
a
+
b
;
resultado
=
a
*
b
;
resultado
=
(
(
(
(
a
+
b
)
*
c
)
2
)
%
10
)
;
soulsand
a
;
resultado
=
a
+
b
;
magma
b
;
resultado
=
a
-
b
;
PolloAsado
worldSave
WorldName
PruebaOpFlotantes
:
Inventory
Ghast
x
=
10.5
;
Ghast
y
=
3.25
;
Ghast
z
;
Ghast
resultado
;
SpawnPoint
PolloCrudo
z
=
x
:
+
y
;
dropperSpider
(
"Suma flotante: "
bind
z
)
;
z
=
x
:
-
y
;
dropperSpider
(
"Resta flotante: "
bind
z
)
;
z
=
x
:
*
y
;
dropperSpider
(
"Multiplicación flotante: "
bind
z
)
;
z
=
x
:
y
;
dropperSpider
(
"División flotante: "
bind
z
)
;
z
=
x
:
%
y
;
dropperSpider
(
"Módulo flotante: "
bind
z
)
;
resultado
=
x
:
+
y
:
*
z
;
dropperSpider
(
"x :+ y :* z = "
bind
resultado
)
;
resultado
=
(
x
:
+
y
)
:
*
z
;
dropperSpider
(
"(x :+ y) :* z = "
bind
resultado
)
;
resultado
=
x
:
+
y
:
+
z
;
dropperSpider
(
"x :+ y :+ z = "
bind
resultado
)
;
resultado
=
x
:
*
y
:
z
:
+
x
:
-
y
;
dropperSpider
(
"x :* y :// z :+ x :- y = "
bind
resultado
)
;
resultado
=
-
x
;
dropperSpider
(
"-x = "
bind
resultado
)
;
resultado
=
5.5
:
+
3.2
;
dropperSpider
(
"5.5 :+ 3.2 = "
bind
resultado
)
;
resultado
=
-
(
x
:
+
y
)
;
dropperSpider
(
"-(x :+ y) = "
bind
resultado
)
;
resultado
=
x
:
+
y
;
resultado
=
x
:
-
y
;
resultado
=
x
:
*
y
;
resultado
=
x
:
y
;
resultado
=
x
:
%
y
;
resultado
=
x
:
+
y
;
resultado
=
x
:
-
y
;
resultado
=
x
:
*
y
;
resultado
=
x
:
y
;
resultado
=
x
:
%
y
;
resultado
=
x
:
+
y
;
resultado
=
x
:
*
y
;
resultado
=
(
(
(
(
x
:
+
y
)
:
*
z
)
:
2.0
)
:
%
10.0
)
;
Ghast
mezcla1
=
x
:
+
5
;
Ghast
mezcla2
=
3.5
:
*
y
;
Ghast
mezcla3
=
x
:
+
(
y
:
*
2.0
)
:
1.5
;
Spider
texto
=
"Notch:Engine"
;
Stack
entero
=
(
x
:
+
y
)
>
>
Stack
;
PolloAsado
worldSave
WorldName
PruebaOpComparacion
:
Inventory
Stack
a
=
10
;
Stack
b
=
5
;
Torch
resultado
;
Ghast
x
=
3.5
;
Ghast
y
=
2.75
;
Spider
cadena1
=
"abc"
;
Spider
cadena2
=
"def"
;
Rune
char1
=
'A'
;
Rune
char2
=
'B'
;
Torch
bool1
=
On
;
Torch
bool2
=
Off
;
SpawnPoint
PolloCrudo
resultado
=
a
<
b
;
dropperSpider
(
"a < b: "
bind
resultado
)
;
resultado
=
x
<
y
;
dropperSpider
(
"x < y: "
bind
resultado
)
;
resultado
=
cadena1
<
cadena2
;
dropperSpider
(
"cadena1 < cadena2: "
bind
resultado
)
;
resultado
=
char1
<
char2
;
dropperSpider
(
"char1 < char2: "
bind
resultado
)
;
resultado
=
a
>
b
;
dropperSpider
(
"a > b: "
bind
resultado
)
;
resultado
=
x
>
y
;
dropperSpider
(
"x > y: "
bind
resultado
)
;
resultado
=
a
<=
b
;
dropperSpider
(
"a <= b: "
bind
resultado
)
;
resultado
=
x
<=
y
;
dropperSpider
(
"x <= y: "
bind
resultado
)
;
resultado
=
a
>=
b
;
dropperSpider
(
"a >= b: "
bind
resultado
)
;
resultado
=
x
>=
y
;
dropperSpider
(
"x >= y: "
bind
resultado
)
;
resultado
=
a
is
b
;
dropperSpider
(
"a is b: "
bind
resultado
)
;
resultado
=
x
is
y
;
dropperSpider
(
"x is y: "
bind
resultado
)
;
resultado
=
cadena1
is
cadena2
;
dropperSpider
(
"cadena1 is cadena2: "
bind
resultado
)
;
resultado
=
bool1
is
bool2
;
dropperSpider
(
"bool1 is bool2: "
bind
resultado
)
;
resultado
=
a
isNot
b
;
dropperSpider
(
"a isNot b: "
bind
resultado
)
;
resultado
=
x
isNot
y
;
dropperSpider
(
"x isNot y: "
bind
resultado
)
;
resultado
=
cadena1
isNot
cadena2
;
dropperSpider
(
"cadena1 isNot cadena2: "
bind
resultado
)
;
resultado
=
bool1
isNot
bool2
;
dropperSpider
(
"bool1 isNot bool2: "
bind
resultado
)
;
resultado
=
a
<
b
;
resultado
=
a
>
b
;
resultado
=
a
<=
b
;
resultado
=
a
>=
b
;
resultado
=
aisb
;
resultado
=
a
is
b
;
resultado
=
aisNotb
;
resultado
=
a
isNot
b
;
resultado
=
a
<
b
;
resultado
=
a
>
b
;
resultado
=
a
<=
b
;
resultado
=
a
>=
b
;
resultado
=
a
is
b
;
resultado
=
a
isNot
b
;
target
a
<
b
craft
hit
PolloCrudo
dropperSpider
(
"a es menor que b"
)
;
PolloAsado
repeater
x
>
y
craft
PolloCrudo
dropperSpider
(
"x es mayor que y"
)
;
PolloAsado
resultado
=
(
a
+
b
)
>
(
x
:
+
y
)
;
resultado
=
a
*
2
<=
b
*
3
;
resultado
=
(
a
2
)
is
(
b
1
)
;
resultado
=
bind
(
cadena1
,
cadena2
)
isNot
"abcdef"
;
Spider
islandia
=
"país"
;
Stack
isNotacion
=
42
;
PolloAsado
worldSave
WorldName
PruebaOpAsignacion
:
Inventory
Stack
contador
=
10
;
Stack
acumulador
=
0
;
Ghast
decimal
=
5.5
;
Spider
texto
=
"Notch"
;
Shelf
[
5
]
Stack
arreglo
;
Entity
Punto
PolloCrudo
Stack
x
;
Stack
y
;
PolloAsado
;
Entity
Punto
punto
;
SpawnPoint
PolloCrudo
contador
=
5
;
dropperSpider
(
"Asignación simple: "
bind
contador
)
;
decimal
=
3.14
;
texto
=
"Engine"
;
contador
+
=
3
;
dropperSpider
(
"Asignación con suma: "
bind
contador
)
;
acumulador
=
0
;
acumulador
+
=
contador
;
acumulador
+
=
2
;
dropperSpider
(
"Acumulador después de += : "
bind
acumulador
)
;
contador
-
=
2
;
dropperSpider
(
"Asignación con resta: "
bind
contador
)
;
acumulador
=
20
;
acumulador
-
=
5
;
acumulador
-
=
contador
;
dropperSpider
(
"Acumulador después de -= : "
bind
acumulador
)
;
contador
*
=
3
;
dropperSpider
(
"Asignación con multiplicación: "
bind
contador
)
;
acumulador
=
2
;
acumulador
*
=
contador
;
dropperSpider
(
"Acumulador después de *= : "
bind
acumulador
)
;
contador
=
2
;
dropperSpider
(
"Asignación con división: "
bind
contador
)
;
acumulador
=
50
;
acumulador
=
5
;
dropperSpider
(
"Acumulador después de /= : "
bind
acumulador
)
;
contador
%
=
3
;
dropperSpider
(
"Asignación con módulo: "
bind
contador
)
;
acumulador
=
17
;
acumulador
%
=
5
;
dropperSpider
(
"Acumulador después de %= : "
bind
acumulador
)
;
arreglo
[
0
]
=
10
;
arreglo
[
1
]
=
20
;
arreglo
[
2
]
=
30
;
arreglo
[
0
]
+
=
5
;
dropperSpider
(
"arreglo[0] después de += : "
bind
arreglo
[
0
]
)
;
arreglo
[
1
]
-
=
5
;
dropperSpider
(
"arreglo[1] después de -= : "
bind
arreglo
[
1
]
)
;
arreglo
[
2
]
*
=
2
;
dropperSpider
(
"arreglo[2] después de *= : "
bind
arreglo
[
2
]
)
;
punto
@
x
=
10
;
punto
@
y
=
20
;
punto
@
x
+
=
5
;
dropperSpider
(
"punto@x después de += : "
bind
punto
@
x
)
;
punto
@
y
-
=
8
;
dropperSpider
(
"punto@y después de -= : "
bind
punto
@
y
)
;
contador
=
5
;
contador
+
=
3
;
contador
-
=
2
;
contador
*
=
4
;
contador
=
2
;
contador
%
=
3
;
contador
=
5
;
contador
+
=
3
;
contador
-
=
2
;
contador
*
=
4
;
contador
=
2
;
contador
%
=
3
;
contador
=
10
;
contador
+
=
5
;
Stack
a
=
1
,
b
=
2
,
c
=
3
;
contador
=
(
a
+
b
)
*
c
;
contador
+
=
a
*
b
;
contador
-
=
a
+
b
;
contador
*
=
(
a
*
2
)
+
(
b
*
3
)
;
contador
=
a
+
1
;
contador
%
=
b
*
2
;
a
=
10
;
b
=
20
;
c
=
30
;
Spider
igual_texto
=
"Este texto tiene un signo = dentro"
;
Spider
mas_texto
=
"Este texto tiene un signo + dentro"
;
Spider
menos_texto
=
"Este texto tiene un signo - dentro"
;
Spider
por_texto
=
"Este texto tiene un signo * dentro"
;
Spider
div_texto
=
"Este texto tiene un signo / dentro"
;
Spider
mod_texto
=
"Este texto tiene un signo % dentro"
;
PolloAsado
worldSave
WorldName
PruebaOpAcceso
:
Inventory
Shelf
[
5
]
Stack
numeros
;
Shelf
[
3
]
Shelf
[
3
]
matriz
;
Shelf
[
2
]
Shelf
[
2
]
Shelf
[
2
]
cubo
;
Spider
texto
=
"Notch Engine"
;
Entity
Punto
PolloCrudo
Stack
x
;
Stack
y
;
Stack
z
;
PolloAsado
;
Entity
Punto
punto
;
Entity
Persona
PolloCrudo
Spider
nombre
;
Stack
edad
;
Torch
activo
;
Shelf
[
3
]
Stack
notas
;
PolloAsado
;
Entity
Persona
estudiante
;
Shelf
[
3
]
Entity
Punto
puntos
;
Entity
Contenedor
PolloCrudo
Shelf
[
5
]
Stack
valores
;
Spider
etiqueta
;
PolloAsado
;
Entity
Contenedor
caja
;
SpawnPoint
PolloCrudo
numeros
[
0
]
=
10
;
numeros
[
1
]
=
20
;
numeros
[
2
]
=
30
;
Stack
valor
=
numeros
[
0
]
;
dropperSpider
(
"Valor en numeros[0]: "
bind
valor
)
;
Stack
indice
=
2
;
valor
=
numeros
[
indice
]
;
dropperSpider
(
"Valor en numeros[indice]: "
bind
valor
)
;
valor
=
numeros
[
1
+
1
]
;
dropperSpider
(
"Valor en numeros[1 + 1]: "
bind
valor
)
;
matriz
[
0
]
[
0
]
=
11
;
matriz
[
0
]
[
1
]
=
12
;
matriz
[
1
]
[
0
]
=
21
;
matriz
[
1
]
[
1
]
=
22
;
valor
=
matriz
[
1
]
[
1
]
;
dropperSpider
(
"Valor en matriz[1][1]: "
bind
valor
)
;
valor
=
matriz
[
indice
-
1
]
[
indice
-
1
]
;
dropperSpider
(
"Valor en matriz[indice - 1][indice - 1]: "
bind
valor
)
;
cubo
[
0
]
[
0
]
[
0
]
=
111
;
cubo
[
1
]
[
1
]
[
1
]
=
222
;
valor
=
cubo
[
1
]
[
1
]
[
1
]
;
dropperSpider
(
"Valor en cubo[1][1][1]: "
bind
valor
)
;
Rune
caracter
=
texto
[
0
]
;
dropperSpider
(
"Carácter en texto[0]: "
bind
caracter
)
;
caracter
=
texto
[
6
]
;
dropperSpider
(
"Carácter en texto[6]: "
bind
caracter
)
;
caracter
=
texto
[
indice
*
2
]
;
dropperSpider
(
"Carácter en texto[indice * 2]: "
bind
caracter
)
;
texto
[
0
]
=
'n'
;
dropperSpider
(
"Texto modificado: "
bind
texto
)
;
punto
@
x
=
10
;
punto
@
y
=
20
;
punto
@
z
=
30
;
valor
=
punto
@
x
;
dropperSpider
(
"Valor en punto@x: "
bind
valor
)
;
punto
@
y
=
punto
@
x
*
2
;
dropperSpider
(
"Valor en punto@y después de asignación: "
bind
punto
@
y
)
;
estudiante
@
nombre
=
"Steve"
;
estudiante
@
edad
=
25
;
estudiante
@
activo
=
On
;
estudiante
@
notas
[
0
]
=
85
;
estudiante
@
notas
[
1
]
=
90
;
estudiante
@
notas
[
2
]
=
95
;
Spider
nombre
=
estudiante
@
nombre
;
dropperSpider
(
"Nombre del estudiante: "
bind
nombre
)
;
Stack
nota
=
estudiante
@
notas
[
1
]
;
dropperSpider
(
"Segunda nota del estudiante: "
bind
nota
)
;
puntos
[
0
]
@
x
=
1
;
puntos
[
0
]
@
y
=
2
;
puntos
[
0
]
@
z
=
3
;
puntos
[
1
]
@
x
=
4
;
puntos
[
1
]
@
y
=
5
;
puntos
[
1
]
@
z
=
6
;
valor
=
puntos
[
1
]
@
y
;
dropperSpider
(
"Valor en puntos[1]@y: "
bind
valor
)
;
caja
@
etiqueta
=
"Items"
;
caja
@
valores
[
0
]
=
100
;
caja
@
valores
[
1
]
=
200
;
valor
=
caja
@
valores
[
1
]
;
dropperSpider
(
"Valor en caja@valores[1]: "
bind
valor
)
;
valor
=
numeros
[
0
]
;
nombre
=
estudiante
@
nombre
;
valor
=
numeros
[
0
]
;
valor
=
matriz
[
1
]
[
1
]
;
nombre
=
estudiante
@
nombre
;
valor
=
cubo
[
0
]
[
matriz
[
0
]
[
0
]
%
3
]
[
numeros
[
0
]
10
]
;
valor
=
numeros
[
0
]
;
nombre
=
estudiante
@
nombre
;
Spider
textoCuadrado
=
"Esto no es un [acceso]"
;
Spider
textoArroba
=
"Email: usuario@dominio.com"
;
PolloAsado
worldSave
WorldName
PruebaOpEspeciales
:
Bedrock
Obsidian
Stack
MAX_SIZE
1024
;
Inventory
Stack
entero
=
42
;
Ghast
flotante
=
3.14159
;
Spider
texto
=
"Notch Engine"
;
Rune
caracter
=
'A'
;
Torch
booleano
=
On
;
Shelf
[
5
]
Stack
arreglo
;
Chest
conjunto
=
{
:
1
,
2
,
3
:
}
;
Entity
Punto
PolloCrudo
Stack
x
;
Stack
y
;
PolloAsado
;
Entity
Punto
punto
;
SpawnPoint
PolloCrudo
Stack
tamanoStack
=
chunk
Stack
;
Stack
tamanoGhast
=
chunk
Ghast
;
Stack
tamanoSpider
=
chunk
Spider
;
Stack
tamanoRune
=
chunk
Rune
;
Stack
tamanoTorch
=
chunk
Torch
;
dropperSpider
(
"Tamaño de Stack en bytes: "
bind
tamanoStack
)
;
dropperSpider
(
"Tamaño de Ghast en bytes: "
bind
tamanoGhast
)
;
dropperSpider
(
"Tamaño de Spider en bytes: "
bind
tamanoSpider
)
;
dropperSpider
(
"Tamaño de Rune en bytes: "
bind
tamanoRune
)
;
dropperSpider
(
"Tamaño de Torch en bytes: "
bind
tamanoTorch
)
;
Stack
tamanoShelf
=
chunk
Shelf
[
5
]
Stack
;
Stack
tamanoChest
=
chunk
Chest
;
Stack
tamanoPunto
=
chunk
Punto
;
dropperSpider
(
"Tamaño de arreglo en bytes: "
bind
tamanoShelf
)
;
dropperSpider
(
"Tamaño de conjunto en bytes: "
bind
tamanoChest
)
;
dropperSpider
(
"Tamaño de Punto en bytes: "
bind
tamanoPunto
)
;
Stack
tamanoVariable
=
chunk
entero
;
Stack
tamanoArreglo
=
chunk
arreglo
;
Stack
tamanoTexto
=
chunk
texto
;
dropperSpider
(
"Tamaño de variable entero en bytes: "
bind
tamanoVariable
)
;
dropperSpider
(
"Tamaño de variable arreglo en bytes: "
bind
tamanoArreglo
)
;
dropperSpider
(
"Tamaño de variable texto en bytes: "
bind
tamanoTexto
)
;
Stack
tamanoExpresion
=
chunk
(
entero
*
2
+
10
)
;
dropperSpider
(
"Tamaño de expresión en bytes: "
bind
tamanoExpresion
)
;
Stack
enteroDeFlotante
=
flotante
>
>
Stack
;
dropperSpider
(
"Flotante convertido a entero: "
bind
enteroDeFlotante
)
;
Torch
booleanoDeEntero
=
entero
>
>
Torch
;
dropperSpider
(
"Entero convertido a booleano: "
bind
booleanoDeEntero
)
;
Rune
caracterDeTexto
=
texto
>
>
Rune
;
dropperSpider
(
"Primer carácter del texto: "
bind
caracterDeTexto
)
;
Stack
resultadoEntero
=
(
flotante
:
+
2.5
)
>
>
Stack
;
dropperSpider
(
"Suma flotante convertida a entero: "
bind
resultadoEntero
)
;
Stack
tam1
=
chunkStack
;
Stack
tam2
=
chunk
Stack
;
Stack
tam3
=
chunk
(
Stack
)
;
Stack
ent1
=
flotante
>
>
Stack
;
Stack
ent2
=
flotante
>
>
Stack
;
Stack
tam4
=
chunk
Stack
;
Stack
ent3
=
flotante
>
>
Stack
;
Stack
tam5
=
chunk
Stack
;
Stack
ent4
=
flotante
>
>
Stack
;
Stack
tamCombinado
=
chunk
(
flotante
>
>
Stack
)
;
Spider
textoMayor
=
"Esto no es una coherción >>"
;
Spider
textoChunk
=
"La palabra chunk no es un operador aquí"
;
Stack
resultado
=
(
flotante
:
*
2.0
>
>
Stack
)
+
(
entero
*
3
)
;
target
(
flotante
>
>
Stack
)
>
3
craft
hit
PolloCrudo
dropperSpider
(
"La parte entera de flotante es mayor que 3"
)
;
PolloAsado
PolloAsado
worldSave
WorldName
PruebaComLinea
:
Bedrock
Obsidian
Stack
MAX_LEVEL
100
;
Obsidian
Spider
VERSION
"1.0"
;
Inventory
Stack
contador
=
0
;
Spider
texto
=
"Notch Engine"
;
Rune
inicial
;
Stack
a
=
10
,
b
=
20
;
Recipe
Spell
calcular
(
Stack
::
a
,
b
)
->
Stack
;
CraftingTable
Spell
calcular
(
Stack
::
a
,
b
)
->
Stack
PolloCrudo
Stack
resultado
=
a
+
b
;
respawn
resultado
;
PolloAsado
Ritual
mostrarMensaje
(
Spider
::
mensaje
)
PolloCrudo
dropperSpider
(
mensaje
)
;
PolloAsado
SpawnPoint
PolloCrudo
contador
=
5
;
target
contador
>
0
craft
hit
PolloCrudo
dropperSpider
(
"Contador positivo"
)
;
PolloAsado
Stack
resultado
=
contador
+
10
;
Stack
suma
=
calcular
(
5
,
10
)
;
;
PolloAsado
worldSave
WorldName
PruebaComBloque
:
Bedrock
Obsidian
Stack
MAX_LEVEL
100
;
Obsidian
Spider
VERSION
"1.0"
;
Inventory
Stack
contador
=
0
;
Spider
texto
=
"Notch Engine"
;
Rune
inicial
;
Stack
a
=
10
,
b
=
20
;
Recipe
Spell
calcular
(
Stack
::
a
,
b
)
->
Stack
;
CraftingTable
Spell
calcular
(
Stack
::
a
,
b
)
->
Stack
PolloCrudo
Stack
resultado
=
a
+
b
;
respawn
resultado
;
PolloAsado
Ritual
mostrarMensaje
(
Spider
::
mensaje
)
PolloCrudo
dropperSpider
(
mensaje
)
;
PolloAsado
SpawnPoint
PolloCrudo
contador
=
5
+
10
;
target
contador
>
0
craft
hit
PolloCrudo
dropperSpider
(
"Contador positivo"
)
;
PolloAsado
dentro
pero
sin
cerrar
aún
*
secuencias
*
PolloAsado
worldSave
WorldName
PruebaComentarios
:
Inventory
Stack
contador
=
10
;
Spider
texto
=
"Comentario /* falso */ dentro de un string"
;
Rune
caracter
=
'*'
;
SpawnPoint
PolloCrudo
dropperSpider
(
"Los comentarios son importantes"
)
;
PolloAsado
worldSave
WorldName
PruebaIdentificadoresSimples
:
Bedrock
Obsidian
Stack
MAX
100
;
Obsidian
Spider
TITULO
"Notch Engine"
;
Inventory
Stack
a
;
Stack
contador
;
Stack
nivel
;
Stack
x
;
Stack
y
;
Stack
z
;
Stack
posicion
;
Stack
altura
;
Stack
ancho
;
Spider
nombre
;
Spider
texto
;
Spider
mensaje
;
Spider
saludo
;
Torch
activo
;
Torch
visible
;
Torch
terminado
;
Rune
inicial
;
Rune
caracter
;
Rune
simbolo
;
Ghast
pi
;
Ghast
temperatura
;
Ghast
velocidad
;
Stack
Contador
;
Spider
Nombre
;
Torch
Activo
;
Stack
i
;
Stack
j
;
Stack
k
;
Rune
c
;
Spider
s
;
Torch
b
;
Ghast
f
;
CraftingTable
Spell
suma
(
Stack
::
a
,
b
)
->
Stack
PolloCrudo
Stack
resultado
;
resultado
=
a
+
b
;
respawn
resultado
;
PolloAsado
Ritual
imprimir
(
Spider
::
mensaje
)
PolloCrudo
dropperSpider
(
mensaje
)
;
PolloAsado
SpawnPoint
PolloCrudo
Stack
valor
;
Stack
resultado
;
Spider
mensaje
;
valor
=
10
;
mensaje
=
"Hola"
;
resultado
=
valor
+
5
;
valor
=
suma
(
valor
,
20
)
;
ender_pearl
imprimir
(
mensaje
)
;
PolloAsado
worldSave
WorldName
PruebaIdentificadoresComplejos
:
Bedrock
Obsidian
Stack
MAX_LEVEL
100
;
Obsidian
Stack
MIN_LEVEL
1
;
Obsidian
Spider
GAME_TITLE
"Notch Engine"
;
Obsidian
Spider
VERSION_1_0
"v1.0"
;
Inventory
Stack
player_level
;
Stack
enemy_count
;
Stack
max_health
;
Stack
min_damage
;
Stack
current_position_x
;
Stack
counter1
;
Stack
item2
;
Stack
level3d
;
Stack
position2d
;
Stack
player1_health
;
Stack
item_1
;
Stack
player_2_score
;
Stack
enemy_level_3
;
Stack
position_x_1
;
Stack
inventory_slot_5
;
Stack
_temp
;
Stack
_internal_counter
;
Stack
_system_value
;
Stack
_player_data
;
Stack
very_long_variable_name_with_many_words
;
Spider
extremely_long_message_text_that_describes_something_in_detail
;
Torch
is_player_currently_in_creative_mode_with_flight_enabled
;
Stack
player5_current_health_max_100
;
Stack
enemy_3d_position_coordinate_x_12
;
Rune
player_initial_1
;
Spider
user_5_name
;
CraftingTable
Spell
calculate_total_damage
(
Stack
::
base_damage
,
critical_multiplier
;
Torch
::
is_headshot
)
->
Stack
PolloCrudo
Stack
total_damage
;
total_damage
=
base_damage
*
critical_multiplier
;
target
is_headshot
craft
hit
PolloCrudo
total_damage
=
total_damage
*
2
;
PolloAsado
respawn
total_damage
;
PolloAsado
Ritual
display_player_stats
(
Spider
::
player_name
;
Stack
level_1
,
health_points_100
)
PolloCrudo
dropperSpider
(
"Player: "
bind
player_name
)
;
dropperSpider
(
"Level: "
bind
level_1
)
;
dropperSpider
(
"Health: "
bind
health_points_100
)
;
PolloAsado
SpawnPoint
PolloCrudo
Stack
player1_health
=
100
;
Stack
enemy_count_5
=
10
;
Spider
main_player_name
=
"Steve_123"
;
player1_health
=
player1_health
-
20
;
enemy_count_5
=
calculate_total_damage
(
10
,
2
,
On
)
;
ender_pearl
display_player_stats
(
main_player_name
,
5
,
player1_health
)
;
Stack
___special_value
=
42
;
dropperStack
(
___special_value
)
;
PolloAsado
worldSave
WorldName
PruebaIdentificadoresSimilares
:
Bedrock
Obsidian
Stack
WorldNameTest
100
;
Obsidian
Spider
BedrockType
"Hard Stone"
;
Obsidian
Torch
InventoryFull
On
;
Inventory
Stack
worldname
;
Stack
WorldName2
;
Stack
bedrock
;
Stack
Bedrock_Type
;
Stack
inventory
;
Stack
InventorySlot
;
Stack
recipe
;
Stack
RecipeBook
;
Stack
craftingtable
;
Stack
CraftingTable2
;
Stack
spawnpoint
;
Stack
SpawnPoint_Main
;
Stack
stack
;
Spider
spider
;
Torch
torch
;
Rune
rune
;
Ghast
ghast
;
Chest
chest
;
Book
book
;
Stack
pollocrudo
;
Stack
PolloAsado
;
Stack
polloAsadoExtra
;
Stack
repeater
;
Stack
target
;
Stack
hit
;
Stack
miss
;
Stack
craft
;
Stack
jukebox
;
Stack
disc
;
Stack
silence
;
Stack
spawner
;
Stack
exhausted
;
Stack
walk
;
Stack
set
;
Stack
to
;
Stack
step
;
Stack
wither
;
Stack
creeper
;
Stack
enderPearl
;
Stack
enderpearlitem
;
Stack
ragequit
;
Stack
spell
;
Stack
Spell_Cast
;
Stack
ritual
;
Stack
RitualCeremony
;
Stack
respawn
;
Stack
respawnPoint
;
Stack
ender_pearl
;
Stack
enderpearlTeleport
;
Stack
soulsand
;
Stack
SoulSandBlock
;
Stack
magma
;
Stack
MagmaBlock
;
Stack
and
;
Stack
andOperator
;
Stack
or
;
Stack
orGate
;
Stack
not
;
Stack
notOperator
;
Stack
xor
;
Stack
xorCalculation
;
Stack
is
;
Stack
isNot
;
Stack
isEqual
;
Torch
on
;
Torch
onSwitch
;
Torch
off
;
Torch
offState
;
Stack
hopper
;
Stack
hopperMinecart
;
Stack
dropper
;
Stack
dropperFunction
;
CraftingTable
Spell
worldNameGenerator
(
)
->
Spider
PolloCrudo
Spider
spawnpoint
=
"DefaultSpawn"
;
Stack
craft
=
10
;
Spider
ritual
=
"Magic"
;
respawn
"Generated"
;
PolloAsado
Ritual
craftingTableMaker
(
Spider
::
recipe
;
Stack
inventory
)
PolloCrudo
Stack
spell
=
20
;
Stack
worldname
=
30
;
Torch
on
=
Off
;
dropperSpider
(
"Crafting table ready"
)
;
PolloAsado
SpawnPoint
PolloCrudo
Stack
worldname
=
1
;
Stack
bedrock
=
2
;
Stack
inventory
=
3
;
Stack
recipe
=
4
;
Stack
craftingtable
=
5
;
Stack
spawnpoint
=
6
;
worldname
=
worldname
+
bedrock
;
inventory
=
craftingtable
*
spawnpoint
;
target
worldname
>
recipe
craft
hit
PolloCrudo
Spider
spell
=
"Magic"
;
dropperSpider
(
spell
)
;
PolloAsado
Spider
generatedName
=
worldNameGenerator
(
)
;
ender_pearl
craftingTableMaker
(
"New Recipe"
,
inventory
)
;
PolloAsado
worldSave
WorldName
PruebaStringsLargos
:
Inventory
Spider
string_normal
=
"Este es un string normal"
;
Spider
string_largo
=
"Este es un string extremadamente largo para probar cómo maneja el analizador léxico los tokens de gran tamaño. El propósito es verificar si el buffer del analizador puede manejar correctamente cadenas que exceden el tamaño típico. En Minecraft, los jugadores pueden construir estructuras enormes y elaboradas, similar a cómo este string se extiende más allá de los límites normales. Las cadenas largas son útiles para almacenar textos extensos como descripciones, historias, o mensajes de diálogo en juegos. Este string sigue creciendo para asegurar que supere los límites habituales de procesamiento del analizador léxico."
;
Spider
string_muy_largo
=
"Este string es aún más largo que el anterior, llegando a aproximadamente mil caracteres para poner realmente a prueba los límites del analizador léxico. En el desarrollo de compiladores, es importante verificar cómo responde el sistema ante casos extremos. Los buffers mal dimensionados podrían causar desbordamientos o truncamientos inesperados. En el mundo de Minecraft, esto sería comparable a construir una megaestructura que se extiende hasta los límites permitidos del mundo. Es crucial que el compilador maneje correctamente estos casos límite, ya que en aplicaciones reales, los usuarios pueden introducir textos extremadamente largos, como documentación, logs detallados, o incluso código generado automáticamente. Este string continúa creciendo, añadiendo más y más caracteres para asegurar que pruebe adecuadamente la capacidad del buffer del analizador léxico. Una implementación robusta debería ser capaz de manejar este token sin problemas, reconociéndolo correctamente como un único string literal, sin importar su longitud. El tamaño máximo debería estar limitado únicamente por la memoria disponible en el sistema, no por limitaciones arbitrarias en el diseño del analizador léxico. Este string sigue y sigue, añadiendo más palabras y caracteres, para garantizar que realmente ponga a prueba los límites del analizador."
;
Spider
string_con_escapes
=
"Este string incluye secuencias de escape como: \n nueva línea, \t tabulación, \" comillas dobles, \\ barra invertida, y otros caracteres especiales como !@#$%^&*()_+-={}[]|:;<>,.?/~`"
;
Spider
string_multilinea
=
"Línea 1\nLínea 2\nLínea 3\nLínea 4\nLínea 5\nLínea 6\nLínea 7\nLínea 8\nLínea 9\nLínea 10\nLínea 11\nLínea 12\nLínea 13\nLínea 14\nLínea 15\nLínea 16\nLínea 17\nLínea 18\nLínea 19\nLínea 20"
;
Spider
string_simbolos
=
"Este string contiene símbolos que son tokens en Notch Engine: +, -, *, //, %, :+, :-, :*, :%, ://, @, [], {}, {: :}, {/ /}, >>. También incluye palabras reservadas como WorldName, Inventory, SpawnPoint, craft, respawn, soulsand, magma, etc."
;
Spider
string_extremo
=
"Este string es extremadamente largo AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA, superando los dos mil caracteres para realmente llevar al límite la capacidad del analizador léxico. En el desarrollo de compiladores e intérpretes, es fundamental probar cómo maneja el sistema casos extremos como este. Cualquier limitación no prevista en el diseño podría manifestarse al procesar tokens de este tamaño. En Minecraft, esto sería equivalente a construir una estructura colosal que se extiende por miles de bloques en todas direcciones, poniendo a prueba los límites del motor del juego. Los analizadores léxicos deben estar preparados para manejar tokens de cualquier longitud razonable, ya que en aplicaciones del mundo real, los usuarios pueden necesitar procesar textos extremadamente largos. Ejemplos incluyen el procesamiento de documentos completos, archivos de configuración extensos, o incluso código generado automáticamente que puede extenderse por miles de líneas. Este string sigue creciendo, añadiendo más y más palabras y caracteres, para asegurar que realmente ponga a prueba los límites del buffer del analizador. Una implementación robusta debería manejar este token sin problemas, reconociéndolo correctamente como un único string literal completo, sin importar su tamaño. El tamaño máximo debería estar limitado únicamente por la memoria disponible en el sistema, no por limitaciones arbitrarias en el diseño del analizador. Este string continúa expandiéndose, añadiendo más contenido para garantizar que supere cualquier buffer de tamaño fijo que pueda haber sido implementado. Es importante también verificar que el rendimiento del analizador no se degrade exponencialmente con tokens muy grandes, lo que podría indicar algoritmos ineficientes. En el contexto de Notch Engine, inspirado en Minecraft, este string sería como un libro dentro del juego con una historia increíblemente detallada que se extiende por múltiples páginas. El analizador léxico debe procesar este token de manera eficiente, reconociéndolo como un único string literal y no fragmentándolo incorrectamente en múltiples tokens. Este string sigue creciendo, agregando más y más caracteres, para asegurar que realmente ponga a prueba los límites del analizador léxico. Continúa expandiéndose, como un mundo de Minecraft que se genera infinitamente, añadiendo más palabras y frases para llegar a una longitud verdaderamente extrema. Este string sigue y sigue y sigue, desafiando las capacidades del analizador, probando su robustez y eficiencia al manejar casos extremos como este."
;
SpawnPoint
PolloCrudo
dropperSpider
(
"Prueba de strings largos completada"
)
;
Stack
longitud
=
#
(
string_largo
)
;
dropperStack
(
longitud
)
;
Spider
subcadena
=
from
string_largo
#
#
0
#
#
50
;
dropperSpider
(
subcadena
)
;
PolloAsado
worldSave
WorldName
PruebaNumeroGrande
:
Bedrock
Obsidian
Stack
NUM_PEQUENO
42
;
Obsidian
Stack
NUM_MEDIANO
12345
;
Obsidian
Stack
NUM_GRANDE
9876543210
;
Obsidian
Stack
NUM_MUY_GRANDE
1234567890123456789
;
Obsidian
Stack
NEG_PEQUENO
-
42
;
Obsidian
Stack
NEG_MEDIANO
-
12345
;
Obsidian
Stack
NEG_GRANDE
-
9876543210
;
Obsidian
Stack
NEG_MUY_GRANDE
-
1234567890123456789
;
Obsidian
Stack
INT_16BIT_MAX
32767
;
Obsidian
Stack
INT_16BIT_MIN
-
32768
;
Obsidian
Stack
INT_32BIT_MAX
2147483647
;
Obsidian
Stack
INT_32BIT_MIN
-
2147483648
;
Obsidian
Stack
INT_64BIT_MAX
9223372036854775807
;
Obsidian
Stack
INT_64BIT_MIN
-
9223372036854775808
;
Obsidian
Stack
NUM_EXTREMO
123456789012345678901234567890
;
Obsidian
Stack
NEG_EXTREMO
-
123456789012345678901234567890
;
Inventory
Stack
num1
=
1234567890
;
Stack
num2
=
9876543210
;
Stack
grande1
=
123456789012345678
;
Stack
grande2
=
987654321098765432
;
Stack
max16
=
32767
;
Stack
min16
=
-
32768
;
Stack
max32
=
2147483647
;
Stack
min32
=
-
2147483648
;
Stack
max64
=
9223372036854775807
;
Stack
min64
=
-
9223372036854775808
;
Stack
extremo
=
123456789012345678901234567890
;
Shelf
[
2147483647
]
Stack
arregloGrande
;
Stack
suma
;
Stack
resta
;
Stack
multiplicacion
;
Stack
division
;
Stack
modulo
;
SpawnPoint
PolloCrudo
suma
=
num1
+
num2
;
resta
=
num2
-
num1
;
multiplicacion
=
num1
*
10
;
division
=
num2
10
;
modulo
=
num2
%
10
;
Stack
resultado1
=
grande1
+
grande2
;
Stack
resultado2
=
extremo
1000
;
Stack
posible_overflow
=
max32
+
1
;
Stack
posible_underflow
=
min32
-
1
;
Stack
producto_grande
=
grande1
*
grande2
;
Stack
division_extrema
=
extremo
3
;
dropperStack
(
suma
)
;
dropperStack
(
resta
)
;
dropperStack
(
multiplicacion
)
;
dropperStack
(
division
)
;
target
producto_grande
>
0
craft
hit
PolloCrudo
dropperSpider
(
"El resultado es positivo"
)
;
PolloAsado
Stack
i
=
0
;
repeater
i
<
5
craft
PolloCrudo
dropperStack
(
i
)
;
dropperStack
(
grande1
)
;
soulsand
i
;
PolloAsado
PolloAsado
worldSave
WorldName
PruebaPrecisionFlotante
:
Bedrock
Obsidian
Ghast
PI_SIMPLE
3.14
;
Obsidian
Ghast
PI_PRECISO
3.14159265358979323846
;
Obsidian
Ghast
EULER
2.71828182845904523536
;
Obsidian
Ghast
RAIZ_DOS
1.41421356237309504880
;
Obsidian
Ghast
PHI
1.61803398874989484820
;
Obsidian
Ghast
SPEED_OF_LIGHT
2.99792458
e8
;
Obsidian
Ghast
PLANCK_CONSTANT
6.62607015
e
-
34
;
Obsidian
Ghast
AVOGADRO
6.02214076
e23
;
Obsidian
Ghast
EXTREMO_PEQUENO
0.0000000000000000000000001
;
Obsidian
Ghast
EXTREMO_GRANDE
123456789012345678901234.5678901234567890
;
Obsidian
Ghast
NEG_PI
-
3.14159265358979
;
Obsidian
Ghast
NEG_EXTREMO
-
0.0000000000000000000000001
;
Obsidian
Ghast
CERO_DECIMAL
0.0
;
Obsidian
Ghast
SOLO_ENTERO
42.0
;
Obsidian
Ghast
SOLO_DECIMAL
0.42
;
Obsidian
Ghast
PUNTO_INICIAL
.
5
;
Inventory
Ghast
normal
=
3.14
;
Ghast
preciso
=
3.141592653589793
;
Ghast
pequeno
=
0.000000000123
;
Ghast
grande
=
1234567890.123456789
;
Ghast
punto_inicial
=
.
25
;
Ghast
sin_decimal
=
42
.
;
Ghast
cientifico1
=
1.23
e5
;
Ghast
cientifico2
=
4.56
e
-
7
;
Ghast
cientifico3
=
7.89
e
+
12
;
Ghast
muy_pequeno
=
0.000000000000000000000000000000000001
;
Ghast
muy_grande
=
999999999999999999999999999999999999999.9
;
Ghast
muchos_digitos
=
123456789012345.678901234567890
;
Ghast
neg_normal
=
-
3.14
;
Ghast
neg_preciso
=
-
3.141592653589793
;
Ghast
neg_pequeno
=
-
0.000000000123
;
Ghast
neg_cientifico
=
-
2.998
e8
;
Ghast
resultado1
;
Ghast
resultado2
;
Ghast
resultado3
;
SpawnPoint
PolloCrudo
resultado1
=
normal
:
+
preciso
;
resultado2
=
preciso
:
-
normal
;
resultado3
=
normal
:
*
2.0
;
Ghast
res_extremo1
=
muy_pequeno
:
*
1000000.0
;
Ghast
res_extremo2
=
muy_grande
:
1000000.0
;
Ghast
division1
=
1.0
:
3.0
;
Ghast
division2
=
2.0
:
3.0
;
Ghast
division_extrema
=
1.0
:
9999999999.0
;
Ghast
res_cientifico
=
cientifico1
:
*
cientifico2
;
dropperGhast
(
resultado1
)
;
dropperGhast
(
resultado2
)
;
dropperGhast
(
division1
)
;
dropperGhast
(
division2
)
;
target
division1
:
<
0.34
craft
hit
PolloCrudo
dropperSpider
(
"La división 1/3 es menor que 0.34"
)
;
PolloAsado
Ghast
i
=
0.0
;
repeater
i
:
<
1.0
craft
PolloCrudo
dropperGhast
(
i
)
;
i
=
i
:
+
0.2
;
PolloAsado
PolloAsado
worldSave
WorldName
PruebaComentarioLargo
:
Inventory
Stack
contador
=
0
;
Stack
despues_comentario
=
1
;
Spider
mensaje
=
"Prueba de comentarios largos"
;
SpawnPoint
PolloCrudo
Stack
i
=
0
;
repeater
i
<
5
craft
PolloCrudo
soulsand
i
;
dropperSpider
(
mensaje
bind
" - iteración "
bind
i
)
;
PolloAsado
dropperSpider
(
"Prueba de comentarios largos completada"
)
;
PolloAsado
worldSave
WorldName
PruebaTokensConsecutivos
:
Bedrock
Obsidian
Stack
MAX_LEVEL5
100
;
Obsidian
Stack
LEVEL_PLUS_SKILL
200
;
Obsidian
Stack
OFFSET_MINUS_5
50
;
Inventory
Stack
a
=
5
;
Stack
b
=
10
;
Stack
c
=
a
+
b
;
Stack
suma
=
5
+
3
;
Stack
resta
=
10
-
7
;
Stack
multiplicacion
=
4
*
3
;
Stack
division
=
20
4
;
Stack
modulo
=
7
%
2
;
Torch
comparacion1
=
5
<
10
;
Torch
comparacion2
=
5
>
3
;
Torch
comparacion3
=
5
<=
5
;
Torch
comparacion4
=
5
>=
5
;
Torch
comparacion5
=
5
is5
;
Torch
comparacion6
=
5
isNot6
;
Stack
expr1
=
5
+
3
*
2
;
Stack
expr2
=
(
5
+
3
)
*
2
;
Stack
expr3
=
5
+
(
3
*
2
)
;
Ghast
f1
=
3.14
;
Ghast
f2
=
f1
:
+
2.5
;
Ghast
f3
=
f1
:
-
1.5
;
Ghast
f4
=
f1
:
*
2.0
;
Ghast
f5
=
f1
:
1.5
;
Shelf
[
5
]
Stack
arreglo
;
Entity
Jugador
PolloCrudo
Spider
nombre
;
Stack
nivel
;
PolloAsado
;
Spider
texto
=
"Hola"
;
Rune
caracter
=
'A'
;
Torch
booleano
=
On
;
Stack
arr
[
0
]
=
10
;
Stack
x
=
1
,
y
=
2
,
z
=
3
;
Stack
normal1
=
10
;
Stack
normal2
=
20
;
Spider
mensaje
=
"Tokens consecutivos"
;
SpawnPoint
PolloCrudo
suma
=
normal1
+
normal2
;
Stack
valor
=
(
normal1
+
5
)
*
(
normal2
-
5
)
;
repeater
suma
>
0
hit
PolloCrudo
suma
=
suma
-
1
;
dropperStack
(
suma
)
;
PolloAsado
target
valor
>=
100
hit
PolloCrudo
dropperSpider
(
"Valor grande"
)
;
PolloAsado
miss
PolloCrudo
dropperSpider
(
"Valor pequeño"
)
;
PolloAsado
dropperSpider
(
mensaje
)
;
dropperStack
(
valor
)
;
normal1
+
=
5
;
normal2
-
=
3
;
dropperStack
(
normal1
)
;
dropperStack
(
normal2
)
;
PolloAsado
worldSave
WorldName
PruebaCaracteresInvalidos
:
Bedrock
Obsidian
Stack
NORMAL
100
;
Obsidian
Stack
ÑANDU
200
;
Obsidian
Stack
AÇÚCAR
300
;
Obsidian
Stack
CAFÉ
400
;
Inventory
Stack
contador
=
0
;
Spider
mensaje
=
"Normal"
;
Stack
año
=
2025
;
Stack
piña
=
10
;
Spider
münzen
=
"Monedas"
;
Spider
öffentlich
=
"Público"
;
Stack
cont
ador
=
5
;
Spider
mens
aje
=
"Texto"
;
Stack
contador
=
10
;
Spider
mensaje
=
"Texto"
;
Stack
monedas
=
100
;
Stack
valor
=
50
;
Spider
texto
=
"Copyright"
;
Spider
texto_unicode
=
"Caracteres especiales: áéíóúñÁÉÍÓÚÑ"
;
Spider
texto_emoji
=
"Emojis: 😀🎮🌍💻"
;
Stack
a
b
;
Stack
c
d
;
Stack
e
f
;
Stack
g
h
;
Stack
valor
otro
;
Stack
valor
contador
=
5
;
Stack
otro
valor
=
10
;
Rune
char_1
=
'€'
;
Rune
char_2
=
'✓'
;
SpawnPoint
PolloCrudo
contador
=
1
;
contador
=
contador
2
;
contador
=
contador
2
;
dropperStack
(
año
)
;
dropperSpider
(
texto_unicode
)
;
contador
=
5
10
;
contador
=
5
10
;
contador
=
5
;
contador
=
contador
+
5
;
dropperSpider
(
"Fin de prueba"
)
;
PolloAsado
worldSave
WorldName
PruebaStringNoTerminado
:
Bedrock
Obsidian
Spider
NOMBRE
"Notch Engine"
;
Obsidian
Spider
VERSION
"1.0"
;
Obsidian
Spider
DESCRIPCION
"Un lenguaje basado en Minecraft;
$$ Constante después del error para verificar recuperación
Obsidian Stack MAX_NIVEL 100;
Inventory
$$ Variables con strings correctamente terminados
Spider normal = "
Este
string
está
bien
";
Spider multilinea = "
Este
string
tiene
nmúltiples
líneas
ny
está
bien
terminado
";
$$ Variable con string no terminado - falta comilla de cierre
Spider incompleto = "
Este
string
no
está
terminado
;
Stack
contador
=
0
;
Spider
confuso
=
"Este string tiene una comilla escapada \" pero no está terminado;
$$ String no terminado al final de una línea
Spider final_linea = "
Este
string
termina
la
línea
pero
no
está
cerrado
Spider
siguiente
=
"Este es un nuevo string"
;
Spider
combinado
=
"String no terminado Stack contador = 5;
$$ String con múltiples líneas pero sin terminar
Spider multilinea_incompleto = "
Este
string
tiene
múltiples
líneas
pero
no
está
terminado
correctamente
;
Spider
comentario_inmediato
=
"String terminado correctamente"
Spider
comentario_error
=
"String no terminado$$ Comentario que no salva el error
$$ String no terminado con comentario de bloque al final
Spider bloque_inmediato = "
String
no
terminado
Spider
consecutivo1
=
"Primer string terminado"
;
Spider
consecutivo2
=
"Segundo string no terminado;
Spider consecutivo3 = "
Tercer
string
terminado
";
SpawnPoint
PolloCrudo
$$ Código normal para contraste
dropperSpider("
Este
mensaje
está
bien
formado
");
$$ Instrucción con string no terminado
dropperSpider("
Este
mensaje
no
está
terminado
;
contador
=
1
;
Spider
resultado
=
normal
bind
"Parte no terminada;
$$ String no terminado en una estructura de control
target normal is "
Comparación
no
terminada
craft
hit
PolloCrudo
dropperSpider
(
"Este código nunca se ejecutará"
)
;
PolloAsado
dropperSpider
(
"String final no terminado
PolloAsado
worldSave
$*
Prueba_Err_ComentarioNoTerminado.ne
Propósito: Verificar detección de comentarios de bloque sin cierre
Fecha: 28/04/2025
*$
WorldName PruebaComentarioNoTerminado:
Bedrock
$$ Constantes normales para contraste
Obsidian Stack MAX_LEVEL 100;
$* Comentario de bloque correctamente cerrado *$
Obsidian Stack MIN_LEVEL 1;
$* Comentario de bloque sin cierre - falta el terminador *$
Obsidian Stack MEDIO_LEVEL 50;
Inventory
$$ Variables normales para contraste
Stack contador = 0;
Spider mensaje = "
Hola
Mundo
";
$*
Comentario de bloque multi-línea correctamente terminado
con varias líneas de texto
*$
Stack variable_normal = 5;
$*
Comentario de bloque multi-línea sin terminar
Este comentario no tiene el terminador correspondiente
y debería generar un error
Torch activo = On; $$ Esta línea no debería ser reconocida como código
Stack valor = 10; $$ Esta línea no debería ser reconocida como código
$$ Variables después del error para verificar recuperación
Stack recuperacion = 20;
$* Otro comentario no terminado
con símbolos que podrían confundir al analizador:
* asterisco suelto
$ signo dólar suelto
*$ esto parece un terminador pero no lo es
$* esto parece un iniciador dentro del comentario
$$ Más código después del segundo comentario no terminado
Torch otra_variable = Off;
$* Comentario aparentemente cerrado, pero con un espacio entre * y $
que debería causar que no se reconozca como terminador * $
$$ Código después del tercer comentario no terminado
Stack tercera_recuperacion = 30;
$*
Este comentario tiene una secuencia que parece un terminador,
pero tiene caracteres en medio: *texto$
Por lo tanto, no está realmente terminado.
$$ Último código para verificar recuperación
Stack ultima_recuperacion = 40;
SpawnPoint
PolloCrudo
$$ Código normal para contraste
dropperSpider("
Inicio
de
programa
");
$* Comentario de bloque sin terminar en el SpawnPoint
Esta sección del código no debería ejecutarse
contador = 5;
dropperStack(contador);
$$ Código después del comentario no terminado
Stack final = 100;
dropperStack(final);
dropperSpider("
Fin
de
programa
");
PolloAsado
$$ Esto debería ser código después del SpawnPoint, que no es válido
$$ pero el analizador léxico igual debería procesarlo como tokens
$*
Comentario final sin terminar
Este es el último elemento del archivo
worldSave
$*
Prueba: 37_Prueba_Err_CaracterNoTerminado
Descripción: Verificar detección de literales de carácter sin cierre
Fecha: 28/04/2025
*$
WorldName PruebaCaracterNoTerminado:
Inventory
$$ Casos de caracteres correctamente formados (para comparación)
Rune letraCorrecta = 'A';
Rune digitoCorrecto = '5';
Rune simboloCorrecto = '@';
Rune escapeCorrecto = '\n';
$$ Casos de caracteres sin cierre (errores léxicos)
Rune errorSimple = 'B; $$ Falta comilla de cierre
Rune errorEscape = '\n; $$ Falta comilla de cierre después de secuencia de escape
$$ Caso con apertura pero sin contenido ni cierre
Rune errorVacio = '; $$ Solo comilla de apertura
$$ Caso con múltiples caracteres (error léxico)
Rune errorMultiple = 'ABC; $$ Múltiples caracteres y falta comilla de cierre
$$ Error dentro de una expresión
Stack valor = 5 + (3 * 'x); $$ Falta comilla de cierre en la expresión
SpawnPoint
PolloCrudo
$$ Este carácter inválido debería ser detectado
Rune pruebaError = 'Z;
dropperSpider("
Este
texto
no
debería
ser
alcanzado
debido
al
error
léxico
");
PolloAsado
worldSave
$*
Prueba: 38_Prueba_Err_SimboloDesconocido
Descripción: Verificar detección de símbolos no reconocidos
Fecha: 28/04/2025
*$
WorldName PruebaSimboloDesconocido:
Bedrock
$$ Símbolos válidos para comparación
Obsidian Stack MAX_VALUE 100;
$$ Símbolo no reconocido: flecha de asignación errónea
Obsidian Stack MIN_VALUE => 0; $$ => no es un símbolo válido
Inventory
$$ Símbolos válidos (para comparación)
Stack contador = 10;
Stack resultado = contador + 5;
$$ Símbolos no reconocidos
Stack valor1 = 5 ^ 2; $$ ^ (potencia) no es un símbolo válido
Stack valor2 = 10 \ 3; $$ \ no es un operador válido
Stack valor3 = valor1 ~ valor2; $$ ~ no es un operador válido
$$ Operadores malformados o incompletos
Stack valor4 = 3 : 4; $$ : solo no es un operador válido (debe ser :+, :-, etc.)
Stack valor5 = 7 / 2; $$ / no es válido (debe ser // para división entera)
$$ Uso de símbolos de otros lenguajes
Stack valor6 = 5 ** 2; $$ ** (potencia en Python) no es válido
Torch condicion = (valor5 == valor6); $$ == no es válido (debe ser 'is')
$$ Símbolo inválido en acceso a estructura
Stack elemento = numeros->0; $$ -> no es válido para acceso (debe ser [])
ResourcePack
$$ Símbolo inválido en declaración de tipo
Anvil Stack ==> Spider; $$ ==> no es un símbolo válido (debe ser ->)
SpawnPoint
PolloCrudo
$$ Operadores inválidos en expresiones
Stack a = 5;
Stack b = 10;
Stack c = a ||| b; $$ ||| no es un operador válido
$$ Símbolos inválidos en estructuras de control
target a < b craft hit
PolloCrudo
dropperSpider("
a
es
menor
que
b
");
PolloAsado
?> $$ ?> no es un símbolo válido
$$ Símbolo inválido como terminador de instrucción
Stack valor = 100#
PolloAsado
worldSave
$*
Prueba: 39_Prueba_Comb_Estructura
Descripción: Verificar estructura básica de un programa completo
Fecha: 28/04/2025
*$
WorldName PruebaEstructuraCompleta:
$$ Sección de constantes
Bedrock
Obsidian Stack MAX_NIVEL 100;
Obsidian Spider VERSION "
1.0
.
0
";
Obsidian Torch DEBUG_MODE Off;
Obsidian Ghast PI 3.14159;
$$ Sección de tipos
ResourcePack
Anvil Ghast -> Stack truncate;
Anvil Stack -> Spider;
$$ Definición de un tipo personalizado
Entity Jugador
PolloCrudo
Spider nombre;
Stack nivel;
Ghast salud;
Torch activo;
PolloAsado;
$$ Sección de variables
Inventory
$$ Variables básicas
Stack contador = 0;
Spider mensaje = "
Bienvenido
a
Notch
Engine
";
Torch juego_activo = On;
Ghast temperatura = 21.5;
Chest letras = {: 'a', 'b', 'c' :};
$$ Variables compuestas
Shelf[5] Stack inventario;
Entity Jugador steve;
$$ Sección de prototipos
Recipe
$$ Prototipo de función
Spell calcularDanio(Stack :: nivel, arma; Ghast ref multiplicador) -> Stack;
$$ Prototipo de procedimiento
Ritual mostrarEstado(Spider :: nombre; Stack nivel, salud);
$$ Sección de implementación de rutinas
CraftingTable
$$ Implementación de función
Spell calcularDanio(Stack :: nivel, arma; Ghast ref multiplicador) -> Stack
PolloCrudo
Stack danio_base = nivel * 2;
target arma is 1 hit
PolloCrudo
danio_base *= 2; $$ Arma mejorada
PolloAsado
multiplicador = 1.5; $$ Modificar parámetro por referencia
respawn danio_base;
PolloAsado
$$ Implementación de procedimiento
Ritual mostrarEstado(Spider :: nombre; Stack nivel, salud)
PolloCrudo
dropperSpider("
==
==
=
Estado
del
Jugador
==
==
=
");
dropperSpider("
Nombre
:
" bind nombre);
dropperSpider("
Nivel
:
" bind nivel);
dropperSpider("
Salud
:
" bind salud);
dropperSpider("
==
==
==
==
==
==
==
==
==
==
==
==
==
==
=
");
PolloAsado
$$ Punto de entrada del programa
SpawnPoint
PolloCrudo
$$ Inicialización
steve@nombre = "
Steve
";
steve@nivel = 1;
steve@salud = 20.0;
steve@activo = On;
$$ Entrada y salida
dropperSpider(mensaje);
dropperSpider("
Ingrese
su
nombre
:
");
Spider nombre_jugador = hopperSpider();
$$ Uso de estructuras de control
target #(nombre_jugador) > 0 hit
PolloCrudo
dropperSpider("
Hola
,
" bind nombre_jugador bind "
");
$$ Uso de funciones y procedimientos
Stack danio = calcularDanio(steve@nivel, 1, 1.0);
dropperSpider("
Tu
daño
base
es
:
" bind danio);
ender_pearl mostrarEstado(steve@nombre, steve@nivel, steve@salud);
$$ Bucle
repeater juego_activo
PolloCrudo
dropperSpider("
Continuar
jugando
(
On
Off
)
");
juego_activo = hopperTorch();
target juego_activo hit
PolloCrudo
soulsand steve@nivel;
dropperSpider("
Nivel
aumentado
a
:
" bind steve@nivel);
PolloAsado
PolloAsado
PolloAsado
miss
PolloCrudo
dropperSpider("
Nombre
no
válido
.
");
PolloAsado
$$ Otros tipos de bucles
Stack i = 0;
spawner
PolloCrudo
soulsand i;
inventario[i] = i * 10;
PolloAsado
exhausted i >= 5;
walk j set 0 to 4
PolloCrudo
dropperSpider("
Inventario
[
" bind j bind "
]
:
" bind inventario[j]);
PolloAsado
PolloAsado
worldSave
$*
Prueba: 40_Prueba_Comb_Declaraciones
Descripción: Verificar combinaciones de declaraciones de variables y constantes
Fecha: 28/04/2025
*$
WorldName PruebaCombinacionDeclaraciones:
$$ Sección de constantes con diferentes tipos y complejidades
Bedrock
$$ Constantes simples de tipos básicos
Obsidian Stack MAX_PLAYERS 8;
Obsidian Stack MIN_LEVEL 1;
Obsidian Torch DEBUG_MODE On;
Obsidian Spider GAME_TITLE "
Notch
Engine
";
Obsidian Rune SEPARATOR '_';
Obsidian Ghast GRAVITY 9.8;
$$ Constantes con expresiones
Obsidian Stack MAX_INVENTORY_SIZE 5 * 9;
Obsidian Stack TOTAL_SLOTS MAX_PLAYERS * MAX_INVENTORY_SIZE;
Obsidian Spider FULL_TITLE GAME_TITLE bind "
v1
.
0
";
Obsidian Ghast TERMINAL_VELOCITY GRAVITY :* 3.0;
$$ Constantes con expresiones más complejas
Obsidian Stack DAYS_IN_YEAR 365;
Obsidian Stack DAYS_IN_4_YEARS DAYS_IN_YEAR * 4 + 1;
Obsidian Torch IS_LEAP_YEAR (DAYS_IN_4_YEARS - (DAYS_IN_YEAR * 4)) is 1;
$$ Declaraciones de tipos con diferentes formas
ResourcePack
$$ Conversiones de tipos básicas
Anvil Ghast -> Stack;
Anvil Ghast -> Stack truncate;
Anvil Stack -> Spider;
Anvil Rune -> Stack safe;
$$ Declaraciones de entidades (registros)
Entity Item
PolloCrudo
Spider nombre;
Stack cantidad;
Stack durabilidad;
Torch stackeable;
PolloAsado;
Entity Jugador
PolloCrudo
Spider nombre;
Stack nivel;
Stack experiencia;
Ghast salud;
Ghast hambre;
Torch en_linea;
Entity Item item_principal;
PolloAsado;
Entity Posicion
PolloCrudo
Stack x;
Stack y;
Stack z;
PolloAsado;
$$ Tipos anidados
Entity Mundo
PolloCrudo
Spider nombre;
Stack seed;
Shelf[10] Entity Jugador jugadores;
Entity Posicion spawn;
PolloAsado;
$$ Sección de variables con diferentes formas de declaración e inicialización
Inventory
$$ Declaraciones simples sin inicialización
Stack contador;
Spider mensaje;
Torch estado;
Rune inicial;
Ghast temperatura;
$$ Declaraciones con inicialización
Stack nivel = 1;
Spider nombre = "
Steve
";
Torch activo = On;
Rune tecla = 'A';
Ghast pi = 3.14159;
$$ Declaraciones múltiples del mismo tipo
Stack x = 0, y = 0, z = 0;
Torch jugando = On, pausa = Off, sonido = On;
Ghast distancia = 0.0, velocidad = 5.0, aceleracion = 1.5;
$$ Declaraciones con resultados de expresiones
Stack suma = 5 + 10;
Stack producto = 4 * 25;
Spider saludo = "
Hola
" bind nombre;
Torch condicion = nivel > 5;
Ghast promedio = (10.5 :+ 20.7 :+ 15.3) :// 3.0;
$$ Declaraciones de tipos compuestos
Shelf[5] Stack inventario;
Shelf[3] Spider mensajes = ["
Hola
", "
Mundo
", "
"];
Shelf[2] Shelf[2] Stack matriz;
Chest numeros = {: 1, 2, 3, 4, 5 :};
Book archivo = {/ "
datos
.
txt
", 'E' /};
$$ Instancias de entidades (registros)
Entity Item espada;
Entity Jugador jugador1
PolloCrudo
nombre: "
Alex
";
nivel: 5;
experiencia: 150;
salud: 18.5;
hambre: 16.0;
en_linea: On;
item_principal:
PolloCrudo
nombre: "
Espada
de
diamante
";
cantidad: 1;
durabilidad: 1500;
stackeable: Off;
PolloAsado;
PolloAsado;
Entity Mundo mundo_principal;
SpawnPoint
PolloCrudo
$$ Inicialización de variables declaradas sin valor inicial
contador = 0;
mensaje = "
Variable
inicializada
en
el
punto
de
entrada
";
estado = Off;
inicial = 'Z';
temperatura = 22.5;
$$ Inicialización de variables compuestas
espada@nombre = "
Espada
de
hierro
";
espada@cantidad = 1;
espada@durabilidad = 250;
espada@stackeable = Off;
matriz[0][0] = 1;
matriz[0][1] = 2;
matriz[1][0] = 3;
matriz[1][1] = 4;
mundo_principal@nombre = "
Mundo
de
prueba
";
mundo_principal@seed = 12345;
mundo_principal@spawn@x = 0;
mundo_principal@spawn@y = 64;
mundo_principal@spawn@z = 0;
$$ Uso de constantes en asignaciones
Stack max_jugadores = MAX_PLAYERS;
dropperSpider(FULL_TITLE);
$$ Uso de referencias a variables en asignaciones
Stack total = nivel + jugador1@nivel;
dropperSpider("
Nivel
total
:
" bind total);
PolloAsado
worldSave
$*
Prueba: 41_Prueba_Comb_Expresiones
Descripción: Verificar expresiones aritméticas y lógicas complejas
Fecha: 28/04/2025
*$
WorldName PruebaExpresionesComplejas:
Bedrock
Obsidian Stack BASE_DAMAGE 10;
Obsidian Stack ARMOR_FACTOR 2;
Obsidian Ghast CRIT_MULTIPLIER 1.5;
Obsidian Torch USE_ADVANCED_FORMULAS On;
Inventory
$$ Variables para las pruebas
Stack a = 5;
Stack b = 10;
Stack c = 15;
Stack resultado_entero;
Ghast x = 2.5;
Ghast y = 3.7;
Ghast z = 1.2;
Ghast resultado_flotante;
Torch p = On;
Torch q = Off;
Torch r = On;
Torch resultado_logico;
Spider str1 = "
Notch
";
Spider str2 = "
Engine
";
Spider resultado_string;
Shelf[5] Stack valores = [10, 20, 30, 40, 50];
Entity Jugador
PolloCrudo
Spider nombre;
Stack nivel;
Ghast salud;
PolloAsado;
Entity Jugador jugador;
SpawnPoint
PolloCrudo
$$ 1. Expresiones aritméticas complejas con enteros
resultado_entero = a + b * c;
dropperSpider("
a
+
b
*
c
=
" bind resultado_entero);
resultado_entero = (a + b) * c;
dropperSpider("
(
a
+
b
)
*
c
=
" bind resultado_entero);
resultado_entero = a + b - c * 2 // 3 % 4;
dropperSpider("
a
+
b
-
c
*
2
3
%
4
=
" bind resultado_entero);
resultado_entero = (a + (b - (c * (2 // (3 % 4)))));
dropperSpider("
Anidada
enteros
:
" bind resultado_entero);
soulsand a;
resultado_entero = a + b;
magma b;
dropperSpider("
Después
de
incremento
decremento
:
" bind resultado_entero);
$$ 2. Expresiones aritméticas complejas con flotantes
resultado_flotante = x :+ y :* z;
dropperSpider("
x
:
+
y
:
*
z
=
" bind resultado_flotante);
resultado_flotante = (x :+ y) :* z;
dropperSpider("
(
x
:
+
y
)
:
*
z
=
" bind resultado_flotante);
resultado_flotante = x :+ y :- z :* 2.0 :// 0.5 :% 1.0;
dropperSpider("
x
:
+
y
:
-
z
:
*
2.0
:
0.5
:
%
1.0
=
" bind resultado_flotante);
resultado_flotante = (x :+ (y :- (z :* (2.0 :// (0.5 :% 1.0)))));
dropperSpider("
Anidada
flotantes
:
" bind resultado_flotante);
$$ 3. Expresiones lógicas complejas
resultado_logico = p and q;
dropperSpider("
p
and
q
=
" bind resultado_logico);
resultado_logico = p or q;
dropperSpider("
p
or
q
=
" bind resultado_logico);
resultado_logico = not p;
dropperSpider("
not
p
=
" bind resultado_logico);
resultado_logico = p xor q;
dropperSpider("
p
xor
q
=
" bind resultado_logico);
resultado_logico = p and q or r;
dropperSpider("
p
and
q
or
r
=
" bind resultado_logico);
resultado_logico = p and (q or r);
dropperSpider("
p
and
(
q
or
r
)
=
" bind resultado_logico);
resultado_logico = not (p and q) or (not r and p);
dropperSpider("
not
(
p
and
q
)
or
(
not
r
and
p
)
=
" bind resultado_logico);
$$ 4. Expresiones de comparación
resultado_logico = a < b;
dropperSpider("
a
<
b
=
" bind resultado_logico);
resultado_logico = a > c;
dropperSpider("
a
>
c
=
" bind resultado_logico);
resultado_logico = a <= b and b >= c;
dropperSpider("
a
<=
b
and
b
>=
c
=
" bind resultado_logico);
resultado_logico = (a is b) or (b is c);
dropperSpider("
(
a
is
b
)
or
(
b
is
c
)
=
" bind resultado_logico);
resultado_logico = a isNot b and b isNot c and a isNot c;
dropperSpider("
a
isNot
b
and
b
isNot
c
and
a
isNot
c
=
" bind resultado_logico);
$$ 5. Expresiones mixtas (combinando tipos)
resultado_logico = (a + b > c) and (x :+ y :> z);
dropperSpider("
(
a
+
b
>
c
)
and
(
x
:
+
y
:
>
z
)
=
" bind resultado_logico);
resultado_logico = (a < b) or (not p) and (x :< y);
dropperSpider("
(
a
<
b
)
or
(
not
p
)
and
(
x
:
<
y
)
=
" bind resultado_logico);
$$ 6. Expresiones con operaciones de cadenas
resultado_string = bind(str1, "
" bind str2);
dropperSpider("
bind
result
:
" bind resultado_string);
Stack longitud = #(resultado_string);
dropperSpider("
Length
:
" bind longitud);
resultado_string = from resultado_string ## 0 ## 5;
dropperSpider("
Substring
:
" bind resultado_string);
Stack pos = seek(resultado_string, "
tch
");
dropperSpider("
Position
of
'tch'
:
" bind pos);
$$ 7. Expresiones con accesos a estructuras
Stack valor_arreglo = valores[2] + valores[3] * valores[4];
dropperSpider("
Array
expression
:
" bind valor_arreglo);
jugador@nombre = "
Steve
";
jugador@nivel = 20;
jugador@salud = 18.5;
Stack nivel_con_bonus = jugador@nivel + 5;
dropperSpider("
Nivel
con
bonus
:
" bind nivel_con_bonus);
Torch nivel_alto = jugador@nivel > 15 and jugador@salud :> 15.0;
dropperSpider("
Nivel
alto
:
" bind nivel_alto);
$$ 8. Expresiones con conversiones de tipo
Stack entero_desde_float = x >> Stack;
dropperSpider("
Entero
desde
float
:
" bind entero_desde_float);
Torch bool_desde_entero = a >> Torch;
dropperSpider("
Booleano
desde
entero
:
" bind bool_desde_entero);
$$ 9. Expresiones extremadamente complejas que combinan múltiples elementos
Stack damage = BASE_DAMAGE + ((jugador@nivel // 2) * (valores[1] + valores[3] // 3));
dropperSpider("
Daño
calculado
:
" bind damage);
target USE_ADVANCED_FORMULAS craft hit
PolloCrudo
Ghast damage_final = ((damage >> Ghast) :* CRIT_MULTIPLIER) :// (1.0 :+ ((valores[4] // 10) >> Ghast));
dropperSpider("
Daño
final
(
fórmula
avanzada
)
:
" bind damage_final);
PolloAsado
miss
PolloCrudo
Stack damage_simple = damage * 2 // (ARMOR_FACTOR + (p and q >> Stack));
dropperSpider("
Daño
final
(
fórmula
simple
)
:
" bind damage_simple);
PolloAsado
PolloAsado
worldSave
$*
Prueba: 42_Prueba_Comb_Control.ne
Descripción: Verificar estructuras de control anidadas
Fecha: 28/04/2025
*$
WorldName PruebaControlAnidado:
Inventory
$$ Variables para las pruebas
Stack contador = 0;
Stack max_iteraciones = 5;
Stack resultado = 0;
Stack opcion = 2;
Torch condicion1 = On;
Torch condicion2 = Off;
Spider mensaje = "
Estructuras
de
control
anidadas
";
Spider resultado_texto = "
";
Shelf[5] Stack matriz = [1, 2, 3, 4, 5];
Entity Personaje
PolloCrudo
Spider nombre;
Stack nivel;
Torch activo;
PolloAsado;
Entity Personaje jugador;
SpawnPoint
dropperSpider(mensaje);
jugador@nombre = "
Steve
";
jugador@nivel = 1;
jugador@activo = On;
$$ 1. Condicionales anidados (if-then-else)
target jugador@nivel >= 1 craft hit
PolloCrudo
dropperSpider("
Nivel
suficiente
para
comenzar
");
target jugador@activo craft hit
PolloCrudo
dropperSpider("
Jugador
activo
");
target jugador@nombre is "
Steve
" craft hit
PolloCrudo
dropperSpider("
Bienvenido
,
Steve
");
soulsand jugador@nivel;
PolloAsado
miss
PolloCrudo
dropperSpider("
Bienvenido
,
jugador
desconocido
");
PolloAsado
PolloAsado
miss
PolloCrudo
dropperSpider("
Jugador
inactivo
.
Activando
.
.
.
");
jugador@activo = On;
PolloAsado
PolloAsado
miss
PolloCrudo
dropperSpider("
Nivel
insuficiente
para
comenzar
");
PolloAsado
$$ 2. Switch anidado dentro de if
target opcion > 0 craft hit
PolloCrudo
jukebox opcion craft
disc 1:
PolloCrudo
dropperSpider("
Opción
1
seleccionada
");
target condicion1 craft hit
PolloCrudo
dropperSpider("
Subopción
A
");
PolloAsado
miss
PolloCrudo
dropperSpider("
Subopción
B
");
PolloAsado
PolloAsado
disc 2:
PolloCrudo
dropperSpider("
Opción
2
seleccionada
");
jukebox jugador@nivel craft
disc 1:
PolloCrudo
dropperSpider("
Nivel
básico
");
PolloAsado
disc 2:
PolloCrudo
dropperSpider("
Nivel
intermedio
");
PolloAsado
silence:
PolloCrudo
dropperSpider("
Nivel
desconocido
");
PolloAsado
PolloAsado
silence:
PolloCrudo
dropperSpider("
Opción
no
reconocida
");
PolloAsado
PolloAsado
$$ 3. Bucles anidados - while dentro de for
walk i set 0 to 2 craft
PolloCrudo
dropperSpider("
Iteración
de
for
principal
:
" bind i);
Stack j = 0;
repeater j < 3 craft
PolloCrudo
dropperSpider("
Subiteración
de
while
:
" bind j);
resultado += (i * 10 + j);
soulsand j;
PolloAsado
PolloAsado
dropperSpider("
Resultado
acumulado
:
" bind resultado);
$$ 4. Bucle do-while con if anidado
contador = 0;
resultado = 0;
spawner
PolloCrudo
soulsand contador;
dropperSpider("
Iteración
do
-
while
:
" bind contador);
target contador % 2 is 0 craft hit
PolloCrudo
dropperSpider("
Número
par
detectado
");
resultado += contador;
PolloAsado
miss
PolloCrudo
dropperSpider("
Número
impar
detectado
");
resultado += contador * 2;
PolloAsado
PolloAsado
exhausted contador >= max_iteraciones;
dropperSpider("
Resultado
tras
do
-
while
:
" bind resultado);
$$ 5. Bucles for anidados con break y continue
resultado = 0;
walk i set 0 to 5 craft
PolloCrudo
target i is 3 craft hit
PolloCrudo
dropperSpider("
Saltando
iteración
i
=
3
");
enderPearl;
PolloAsado
dropperSpider("
For
externo
:
" bind i);
walk j set 0 to 3 craft
PolloCrudo
target i is 4 and j > 1 craft hit
PolloCrudo
dropperSpider("
Terminando
loop
interno
en
i
=
4
,
j
=
" bind j);
creeper;
PolloAsado
resultado += (i + j);
dropperSpider("
For
interno
:
j
=
" bind j bind "
,
suma
acumulada
=
" bind resultado);
PolloAsado
PolloAsado
$$ 6. Combinación compleja: with dentro de if-else dentro de while
contador = 0;
resultado = 0;
repeater contador < 3 craft
PolloCrudo
soulsand contador;
dropperSpider("
Iteración
while
principal
:
" bind contador);
target contador % 2 is 0 craft hit
PolloCrudo
wither jugador craft
PolloCrudo
activo = Off;
dropperSpider("
" bind nombre bind "
desactivado
temporalmente
");
spawner
PolloCrudo
soulsand nivel;
dropperSpider("
Incrementando
nivel
:
" bind nivel);
PolloAsado
exhausted nivel > contador + 2;
activo = On;
dropperSpider("
" bind nombre bind "
reactivado
con
nivel
" bind nivel);
PolloAsado
PolloAsado
miss
PolloCrudo
Stack temp_nivel = jugador@nivel;
repeater temp_nivel > 0 craft
PolloCrudo
dropperSpider("
Reduciendo
nivel
temporal
:
" bind temp_nivel);
target temp_nivel is 1 craft hit
PolloCrudo
dropperSpider("
Nivel
mínimo
alcanzado
");
creeper;
PolloAsado
magma temp_nivel;
PolloAsado
PolloAsado
PolloAsado
$$ 7. Estructuras de control con expresiones complejas en las condiciones
walk i set 0 to matriz[2] + matriz[4] // 2 craft
PolloCrudo
target (i * 2 <= matriz[i % 5]) and ((i % 2 is 0) or (i is matriz[0])) craft hit
PolloCrudo
dropperSpider("
Condición
compleja
satisfecha
en
i
=
" bind i);
resultado += i;
PolloAsado
PolloAsado
dropperSpider("
Resultado
final
:
" bind resultado);
$$ 8. Instrucción ragequit condicionada anidada
target contador >= max_iteraciones and resultado < 100 craft hit
PolloCrudo
target jugador@nivel < 5 craft hit
PolloCrudo
dropperSpider("
Condiciones
críticas
alcanzadas
.
Terminando
programa
.
");
ragequit;
PolloAsado
PolloAsado
dropperSpider("
Programa
completado
con
éxito
.
");
worldSave
$*
Prueba: 43_Prueba_Rend_MuchosTokens
Descripción: Verificar rendimiento con un archivo con miles de tokens
Fecha: 28/04/2025
*$
WorldName PruebaMuchosTokens:
Bedrock
Obsidian Stack MAX_ITERATIONS 1000;
Obsidian Stack ARRAY_SIZE 500;
Obsidian Stack STEP_VALUE 1;
Obsidian Spider TEST_NAME "
Prueba
de
rendimiento
con
muchos
tokens
";
ResourcePack
Entity TestData
PolloCrudo
Stack id;
Stack value;
Ghast weight;
Spider name;
Torch active;
PolloAsado;
Inventory
$$ Declaramos variables extensas para generar muchos tokens
Shelf[500] Stack numbers;
$$ Creamos un array grande de registros
Shelf[100] Entity TestData records;
$$ Variables para el procesamiento
Stack counter;
Stack sum;
Stack product;
Stack max_value;
Stack min_value;
Ghast average;
Stack i;
Stack j;
Stack k;
Stack temp;
Torch condition;
SpawnPoint
dropperSpider(TEST_NAME);
dropperSpider("
Inicializando
arrays
.
.
.
");
$$ Inicialización masiva del array de enteros
walk i set 0 to ARRAY_SIZE - 1 craft
PolloCrudo
numbers[i] = i * STEP_VALUE;
PolloAsado
$$ Inicialización del array de registros
walk i set 0 to 99 craft
PolloCrudo
records[i]@id = i;
records[i]@value = i * 10;
records[i]@weight = i :* 0.5;
records[i]@name = "
Item_
" bind i;
records[i]@active = i % 2 is 0;
PolloAsado
dropperSpider("
Realizando
cálculos
.
.
.
");
$$ Cálculos repetitivos generando miles de tokens
sum = 0;
product = 1;
max_value = numbers[0];
min_value = numbers[0];
$$ Bucle con muchas operaciones
walk i set 0 to ARRAY_SIZE - 1 craft
PolloCrudo
$$ Acumuladores simples
sum += numbers[i];
$$ Para evitar overflow, sólo multiplicamos los primeros 10 valores
target i < 10 craft hit
PolloCrudo
product *= numbers[i] + 1;
PolloAsado
$$ Cálculo de máximo y mínimo
target numbers[i] > max_value craft hit
PolloCrudo
max_value = numbers[i];
PolloAsado
target numbers[i] < min_value craft hit
PolloCrudo
min_value = numbers[i];
PolloAsado
$$ Operaciones condicionales adicionales
target i % 50 is 0 craft hit
PolloCrudo
dropperSpider("
Procesado
" bind i bind "
elementos
.
.
.
");
PolloAsado
PolloAsado
$$ Cálculo de promedio
average = sum >> Ghast :// (ARRAY_SIZE >> Ghast);
dropperSpider("
Procesamiento
completado
.
Resultados
:
");
dropperSpider("
Suma
total
:
" bind sum);
dropperSpider("
Producto
(
primeros
10
)
:
" bind product);
dropperSpider("
Valor
máximo
:
" bind max_value);
dropperSpider("
Valor
mínimo
:
" bind min_value);
dropperSpider("
Promedio
:
" bind average);
$$ Procesamiento de registros - para generar más tokens
dropperSpider("
Procesando
registros
.
.
.
");
counter = 0;
walk i set 0 to 99 craft
PolloCrudo
target records[i]@active craft hit
PolloCrudo
soulsand counter;
$$ Actualizar el valor basado en otros registros
walk j set 0 to i craft
PolloCrudo
records[i]@value += j;
PolloAsado
PolloAsado
PolloAsado
dropperSpider("
Registros
activos
:
" bind counter);
$$ Algoritmo de ordenamiento burbuja para generar aún más tokens
dropperSpider("
Ordenando
array
.
.
.
");
walk i set 0 to ARRAY_SIZE - 2 craft
PolloCrudo
walk j set 0 to ARRAY_SIZE - i - 2 craft
PolloCrudo
target numbers[j] > numbers[j + 1] craft hit
PolloCrudo
$$ Intercambio
temp = numbers[j];
numbers[j] = numbers[j + 1];
numbers[j + 1] = temp;
PolloAsado
PolloAsado
PolloAsado
dropperSpider("
Array
ordenado
.
");
$$ Búsqueda binaria para generar más tokens
dropperSpider("
Realizando
búsquedas
.
.
.
");
walk k set 0 to 20 craft
PolloCrudo
Stack valor_buscar = k * 25;
Stack inicio = 0;
Stack fin = ARRAY_SIZE - 1;
Stack medio;
Stack encontrado = 0;
repeater inicio <= fin craft
PolloCrudo
medio = (inicio + fin) // 2;
target numbers[medio] is valor_buscar craft hit
PolloCrudo
encontrado = 1;
creeper;
PolloAsado
target numbers[medio] < valor_buscar craft hit
PolloCrudo
inicio = medio + 1;
PolloAsado
miss
PolloCrudo
fin = medio - 1;
PolloAsado
PolloAsado
target encontrado craft hit
PolloCrudo
dropperSpider("
Valor
" bind valor_buscar bind "
encontrado
en
posición
" bind medio);
PolloAsado
miss
PolloCrudo
dropperSpider("
Valor
" bind valor_buscar bind "
no
encontrado
");
PolloAsado
PolloAsado
dropperSpider("
Prueba
de
rendimiento
completada
.
");
worldSave
$*
Prueba: 44_Prueba_Rend_TokensRepetidos
Descripción: Verificar rendimiento con patrones repetitivos
Fecha: 28/04/2025
*$
WorldName PruebaTokensRepetidos:
Bedrock
Obsidian Stack MAX_ITERATIONS 500;
Obsidian Stack PATTERN_LENGTH 20;
Inventory
$$ Variables para la prueba
Stack counter = 0;
Stack total = 0;
Stack temp = 0;
Torch flag = On;
SpawnPoint
dropperSpider("
Iniciando
prueba
de
rendimiento
con
tokens
repetitivos
");
$$ =================================================================
$$ Patrón 1: Repetición masiva de operaciones aritméticas
$$ =================================================================
counter = 0;
total = 0;
repeater counter < MAX_ITERATIONS craft
PolloCrudo
$$ Patrón de operaciones aritméticas que se repite
total = total + 1;
total = total - 1;
total = total + 2;
total = total - 1;
total = total + 3;
total = total - 2;
total = total * 2;
total = total // 2;
total = total + 5;
total = total % 10;
total = total + 1;
total = total - 1;
total = total + 2;
total = total - 1;
total = total + 3;
total = total - 2;
total = total * 2;
total = total // 2;
total = total + 5;
total = total % 10;
soulsand counter;
PolloAsado
dropperSpider("
Patrón
1
completado
.
Total
:
" bind total);
$$ =================================================================
$$ Patrón 2: Repetición masiva de operaciones lógicas
$$ =================================================================
counter = 0;
flag = On;
repeater counter < MAX_ITERATIONS craft
PolloCrudo
$$ Patrón de operaciones lógicas que se repite
flag = flag and On;
flag = flag or Off;
flag = not flag;
flag = flag and On;
flag = flag or Off;
flag = not flag;
flag = flag xor On;
flag = flag xor Off;
flag = flag and On;
flag = not flag;
flag = flag and On;
flag = flag or Off;
flag = not flag;
flag = flag and On;
flag = flag or Off;
flag = not flag;
flag = flag xor On;
flag = flag xor Off;
flag = flag and On;
flag = not flag;
soulsand counter;
PolloAsado
dropperSpider("
Patrón
2
completado
.
Estado
final
:
" bind flag);
$$ =================================================================
$$ Patrón 3: Repetición masiva de evaluaciones condicionales
$$ =================================================================
counter = 0;
total = 0;
repeater counter < MAX_ITERATIONS craft
PolloCrudo
$$ Patrón de condicionales que se repite
target counter % 2 is 0 craft hit
PolloCrudo
total += 1;
PolloAsado
miss
PolloCrudo
total += 2;
PolloAsado
target counter % 3 is 0 craft hit
PolloCrudo
total += 3;
PolloAsado
miss
PolloCrudo
total += 1;
PolloAsado
target counter % 5 is 0 craft hit
PolloCrudo
total += 5;
PolloAsado
miss
PolloCrudo
total += 2;
PolloAsado
target counter % 7 is 0 craft hit
PolloCrudo
total += 7;
PolloAsado
miss
PolloCrudo
total += 3;
PolloAsado
target total > 1000 craft hit
PolloCrudo
total = total % 1000;
PolloAsado
soulsand counter;
PolloAsado
dropperSpider("
Patrón
3
completado
.
Total
:
" bind total);
$$ =================================================================
$$ Patrón 4: Repetición masiva de incremento/decremento
$$ =================================================================
counter = 0;
total = 500;
repeater counter < MAX_ITERATIONS craft
PolloCrudo
$$ Patrón de incremento/decremento que se repite
soulsand total;
soulsand total;
soulsand total;
magma total;
magma total;
soulsand total;
soulsand total;
magma total;
soulsand total;
magma total;
soulsand total;
soulsand total;
soulsand total;
magma total;
magma total;
soulsand total;
soulsand total;
magma total;
soulsand total;
magma total;
soulsand counter;
PolloAsado
dropperSpider("
Patrón
4
completado
.
Total
:
" bind total);
$$ =================================================================
$$ Patrón 5: Repetición masiva de operaciones de asignación compuesta
$$ =================================================================
counter = 0;
total = 5;
repeater counter < MAX_ITERATIONS craft
PolloCrudo
$$ Patrón de asignaciones compuestas que se repite
total += 5;
total -= 2;
total *= 2;
total //= 2;
total %= 10;
total += 1;
total -= 1;
total *= 3;
total //= 3;
total %= 5;
total += 5;
total -= 2;
total *= 2;
total //= 2;
total %= 10;
total += 1;
total -= 1;
total *= 3;
total //= 3;
total %= 5;
soulsand counter;
PolloAsado
dropperSpider("
Patrón
5
completado
.
Total
:
" bind total);
$$ =================================================================
$$ Patrón 6: Repetición masiva de operadores de comparación
$$ =================================================================
counter = 0;
total = 0;
temp = 50;
repeater counter < MAX_ITERATIONS craft
PolloCrudo
$$ Patrón de comparaciones que se repite
target counter < temp craft hit total += 1; PolloAsado
target counter > temp craft hit total += 1; PolloAsado
target counter <= temp craft hit total += 1; PolloAsado
target counter >= temp craft hit total += 1; PolloAsado
target counter is temp craft hit total += 1; PolloAsado
target counter isNot temp craft hit total += 1; PolloAsado
target counter < 100 craft hit total += 1; PolloAsado
target counter > 0 craft hit total += 1; PolloAsado
target counter <= 100 craft hit total += 1; PolloAsado
target counter >= 0 craft hit total += 1; PolloAsado
target counter < temp craft hit total += 1; PolloAsado
target counter > temp craft hit total += 1; PolloAsado
target counter <= temp craft hit total += 1; PolloAsado
target counter >= temp craft hit total += 1; PolloAsado
target counter is temp craft hit total += 1; PolloAsado
target counter isNot temp craft hit total += 1; PolloAsado
target counter < 100 craft hit total += 1; PolloAsado
target counter > 0 craft hit total += 1; PolloAsado
target counter <= 100 craft hit total += 1; PolloAsado
target counter >= 0 craft hit total += 1; PolloAsado
soulsand counter;
PolloAsado
dropperSpider("
Patrón
6
completado
.
Total
:
" bind total);
dropperSpider("
Prueba
de
rendimiento
con
tokens
repetitivos
completada
.
");
worldSave
$*
Prueba: 45_Prueba_Rend_TokensVariados
Descripción: Verificar rendimiento con variedad de tokens mezclados
Fecha: 28/04/2025
*$
WorldName PruebaTokensVariados:
$$ Sección de constantes para controlar el tamaño de la prueba
Bedrock
Obsidian Stack ITERATIONS 100;
Obsidian Stack MAX_VALUE 1000;
Obsidian Stack ARRAY_SIZE 50;
Obsidian Spider TEST_NAME "
Prueba
de
rendimiento
con
tokens
variados
";
Obsidian Spider VERSION "
1.0
";
Obsidian Ghast PI 3.14159;
Obsidian Torch DEBUG_MODE On;
$$ Definiciones de tipos variados para generar diversidad de tokens
ResourcePack
Entity Posicion
PolloCrudo
Stack x;
Stack y;
Stack z;
PolloAsado;
Entity Item
PolloCrudo
Spider nombre;
Stack cantidad;
Stack durabilidad;
Ghast peso;
Torch consumible;
PolloAsado;
Entity Jugador
PolloCrudo
Spider nombre;
Stack nivel;
Ghast salud;
Entity Posicion posicion;
Shelf[10] Entity Item inventario;
PolloAsado;
Anvil Ghast -> Stack truncate;
Anvil Stack -> Spider;
Anvil Spider -> Stack;
Anvil Stack -> Torch;
Inventory
Stack contador = 0;
Stack suma = 0;
Stack producto = 1;
Ghast pi = 3.14159;
Ghast e = 2.71828;
Ghast resultado_flotante = 0.0;
Spider texto = "
Prueba
de
rendimiento
";
Spider resultado_texto = "
";
Rune caracter = 'A';
Torch condicion = On;
Shelf[ARRAY_SIZE] Stack numeros;
Shelf[ARRAY_SIZE] Ghast valores_reales;
Shelf[10] Spider textos = ["
uno
", "
dos
", "
tres
", "
cuatro
", "
cinco
", "
seis
", "
siete
", "
ocho
", "
nueve
", "
diez
"];
Chest conjunto_numeros = {: 1, 2, 3, 4, 5 :};
Chest conjunto_caracteres = {: 'a', 'b', 'c', 'd', 'e' :};
Book archivo_log = {/ "
log
.
txt
", 'E' /};
Book archivo_datos = {/ "
datos
.
dat
", 'L' /};
Entity Posicion origen
PolloCrudo
x: 0;
y: 0;
z: 0;
PolloAsado;
Entity Item espada
PolloCrudo
nombre: "
Espada
de
diamante
";
cantidad: 1;
durabilidad: 1000;
peso: 5.0;
consumible: Off;
PolloAsado;
Entity Jugador jugador_principal;
Entity Jugador jugadores[5];
Recipe
Spell calcularDanio(Stack :: nivel; Ghast :: multiplicador) -> Stack;
Spell distanciaEntre(Entity Posicion :: pos1, pos2) -> Ghast;
Spell crearItem(Spider :: nombre; Stack cantidad, durabilidad; Ghast peso; Torch consumible) -> Entity Item;
Ritual inicializarJugador(Entity Jugador ref jugador; Spider :: nombre; Stack nivel; Ghast salud);
Ritual mostrarEstadisticas(Entity Jugador :: jugador);
Ritual procesarInventario(Shelf[10] Entity Item :: inventario);
CraftingTable
Spell calcularDanio(Stack :: nivel; Ghast :: multiplicador) -> Stack
PolloCrudo
Stack danio_base = nivel * 2 + 5;
Stack danio_final = danio_base;
target nivel > 10 craft hit
PolloCrudo
danio_final += (nivel - 10) * 3;
PolloAsado
Ghast temp = danio_final >> Ghast;
temp = temp :* multiplicador;
danio_final = temp >> Stack;
respawn danio_final;
PolloAsado
Spell distanciaEntre(Entity Posicion :: pos1, pos2) -> Ghast
PolloCrudo
Stack dx = pos1@x - pos2@x;
Stack dy = pos1@y - pos2@y;
Stack dz = pos1@z - pos2@z;
Ghast dx_float = dx >> Ghast;
Ghast dy_float = dy >> Ghast;
Ghast dz_float = dz >> Ghast;
Ghast suma_cuadrados = (dx_float :* dx_float) :+ (dy_float :* dy_float) :+ (dz_float :* dz_float);
Ghast result = suma_cuadrados :// 2.0;
respawn result;
PolloAsado
Spell crearItem(Spider :: nombre; Stack cantidad, durabilidad; Ghast peso; Torch consumible) -> Entity Item
PolloCrudo
Entity Item nuevo_item
PolloCrudo
nombre: nombre;
cantidad: cantidad;
durabilidad: durabilidad;
peso: peso;
consumible: consumible;
PolloAsado;
respawn nuevo_item;
PolloAsado
Ritual inicializarJugador(Entity Jugador ref jugador; Spider :: nombre; Stack nivel; Ghast salud)
PolloCrudo
jugador@nombre = nombre;
jugador@nivel = nivel;
jugador@salud = salud;
jugador@posicion@x = 0;
jugador@posicion@y = 0;
jugador@posicion@z = 0;
walk i set 0 to 9 craft
PolloCrudo
jugador@inventario[i] = crearItem("
Item_
" bind i, i + 1, 100 * (i + 1), i :* 0.5, i % 2 is 0);
PolloAsado
PolloAsado
Ritual mostrarEstadisticas(Entity Jugador :: jugador)
PolloCrudo
dropperSpider("
==
=
Estadísticas
del
Jugador
==
=
");
dropperSpider("
Nombre
:
" bind jugador@nombre);
dropperSpider("
Nivel
:
" bind jugador@nivel);
dropperSpider("
Salud
:
" bind jugador@salud);
dropperSpider("
Posición
:
(
" bind jugador@posicion@x bind "
,
" bind jugador@posicion@y bind "
,
" bind jugador@posicion@z bind "
)
");
dropperSpider("
Inventario
:
" bind #(jugador@inventario) bind "
items
");
PolloAsado
Ritual procesarInventario(Shelf[10] Entity Item :: inventario)
PolloCrudo
Stack total_items = 0;
Ghast peso_total = 0.0;
Spider lista_items = "
";
walk i set 0 to 9 craft
PolloCrudo
total_items += inventario[i]@cantidad;
peso_total = peso_total :+ (inventario[i]@peso :* inventario[i]@cantidad >> Ghast);
target i < 9 craft hit
PolloCrudo
lista_items = lista_items bind inventario[i]@nombre bind "
,
";
PolloAsado
miss
PolloCrudo
lista_items = lista_items bind inventario[i]@nombre;
PolloAsado
PolloAsado
dropperSpider("
Total
items
:
" bind total_items);
dropperSpider("
Peso
total
:
" bind peso_total);
dropperSpider("
Lista
:
" bind lista_items);
PolloAsado
SpawnPoint
dropperSpider(TEST_NAME bind "
v
" bind VERSION);
walk i set 0 to ARRAY_SIZE - 1 craft
PolloCrudo
numeros[i] = (i * i + i) % MAX_VALUE;
valores_reales[i] = i :* PI :// 10.0;
target i < 20 craft hit
PolloCrudo
add(conjunto_numeros, i * 10);
PolloAsado
PolloAsado
jugador_principal@nombre = "
Aventurero
";
jugador_principal@nivel = 25;
jugador_principal@salud = 95.5;
jugador_principal@posicion@x = 100;
jugador_principal@posicion@y = 64;
jugador_principal@posicion@z = -50;
walk i set 0 to 4 craft
PolloCrudo
Spider nombre_jugador = "
Jugador_
" bind i;
Stack nivel_inicial = 1 + i * 5;
Ghast salud_inicial = 20.0 :+ (i :* 5.0);
ender_pearl inicializarJugador(jugadores[i], nombre_jugador, nivel_inicial, salud_inicial);
PolloAsado
dropperSpider("
Realizando
operaciones
mezcladas
.
.
.
");
contador = 0;
suma = 0;
producto = 1;
resultado_texto = "
";
walk iteracion set 0 to ITERATIONS - 1 craft
PolloCrudo
Stack indice = iteracion % ARRAY_SIZE;
suma += numeros[indice];
target producto < 1000000 craft hit
PolloCrudo
producto *= (indice + 1);
PolloAsado
Ghast valor_real = valores_reales[indice];
resultado_flotante = resultado_flotante :+ valor_real;
target resultado_flotante :> 1000.0 craft hit
PolloCrudo
resultado_flotante = resultado_flotante :% 1000.0;
PolloAsado
Spider texto_iteracion = textos[iteracion % 10];
target iteracion % 5 is 0 craft hit
PolloCrudo
resultado_texto = resultado_texto bind texto_iteracion;
PolloAsado
target iteracion % 2 is 0 craft hit
PolloCrudo
caracter = etchUp(caracter);
PolloAsado
miss
PolloCrudo
caracter = etchDown(caracter);
PolloAsado
condicion = condicion xor (iteracion % 3 is 0);
target indice % 2 is 0 and condicion craft hit
PolloCrudo
soulsand contador;
PolloAsado
target iteracion % 10 is 0 craft hit
PolloCrudo
Stack danio = calcularDanio(jugador_principal@nivel, 1.5);
Ghast distancia = distanciaEntre(jugador_principal@posicion, origen);
dropperSpider("
Iteración
" bind iteracion bind "
:
Daño
=
" bind danio bind "
,
Distancia
=
" bind distancia);
PolloAsado
Stack jugador_indice = iteracion % 5;
soulsand jugadores[jugador_indice]@nivel;
target iteracion % 20 is 0 craft hit
PolloCrudo
ender_pearl mostrarEstadisticas(jugadores[jugador_indice]);
PolloAsado
PolloAsado
dropperSpider("
Prueba
completada
.
Resultados
:
");
dropperSpider("
Suma
total
:
" bind suma);
dropperSpider("
Producto
acumulado
:
" bind producto);
dropperSpider("
Resultado
flotante
:
" bind resultado_flotante);
dropperSpider("
Texto
resultante
:
" bind resultado_texto);
dropperSpider("
Caracter
final
:
" bind caracter);
dropperSpider("
Contador
incrementado
:
" bind contador);
dropperSpider("
Estado
de
condición
final
:
" bind condicion);
ender_pearl procesarInventario(jugador_principal@inventario);
dropperSpider("
Prueba
de
rendimiento
con
tokens
variados
finalizada
");
worldSave
$*
Prueba_PR_Estructura.ne
Propósito: Verificar el reconocimiento de palabras reservadas de estructura del programa
Probar: WorldName, Bedrock, ResourcePack, Inventory, Recipe, CraftingTable, SpawnPoint
Fecha: 28/04/2025
*$
$$ Prueba de la estructura básica del programa NotchEngine
$$ Verificando las palabras reservadas: WorldName, Bedrock, ResourcePack, Inventory, Recipe, CraftingTable, SpawnPoint
WorldName PruebaEstructura:
Bedrock
Obsidian Stack MAX_VALOR 100;
Obsidian Spider SALUDO "
Prueba
de
estructura
";
ResourcePack
Anvil Stack -> Spider;
Inventory
Stack contador = 0;
Spider mensaje = "
Hola
mundo
";
Recipe
Spell sumar(Stack :: a, b) -> Stack;
Ritual mostrarMensaje(Spider :: texto);
CraftingTable
Spell sumar(Stack :: a, b) -> Stack
PolloCrudo
Stack resultado = a + b;
respawn resultado;
PolloAsado
Ritual mostrarMensaje(Spider :: texto)
PolloCrudo
dropperSpider(texto);
PolloAsado
SpawnPoint
PolloCrudo
dropperSpider(SALUDO);
Stack resultado = sumar(5, 10);
dropperSpider("
El
resultado
es
:
" bind resultado);
PolloAsado
worldSave
$*
Prueba_PR_Tipos.ne
Propósito: Verificar reconocimiento de tipos de datos en NotchEngine
Probar: Stack, Rune, Spider, Torch, Chest, Book, Ghast, Shelf, Entity
Fecha: 28/04/2025
*$
$$ Prueba de los tipos de datos en NotchEngine
$$ Verificando: Stack, Rune, Spider, Torch, Chest, Book, Ghast, Shelf, Entity
WorldName PruebaTipos:
Inventory
$$ Declaraciones de variables de cada tipo
$$ Stack - Tipo de dato entero
Stack entero = 42;
$$ Rune - Tipo de dato carácter
Rune caracter = 'N';
$$ Spider - Tipo de dato string
Spider texto = "
NotchEngine
";
$$ Torch - Tipo de dato booleano
Torch verdadero = On;
Torch falso = Off;
$$ Chest - Tipo de dato conjunto
Chest numeros = {: 1, 2, 3, 4, 5 :};
$$ Book - Tipo de dato archivo de texto
Book archivo = {/ "
datos
.
txt
", 'E' /};
$$ Ghast - Tipo de datos números flotantes
Ghast decimal = 3.14159;
$$ Shelf - Tipo de dato arreglos
Shelf[5] Stack arreglo = [1, 2, 3, 4, 5];
$$ Entity - Tipo de dato registros
Entity Jugador
PolloCrudo
Spider nombre;
Stack nivel;
Ghast salud;
PolloAsado;
Entity Jugador jugador = {nombre: "
Steve
", nivel: 1, salud: 20.0};
SpawnPoint
PolloCrudo
dropperSpider("
Prueba
de
tipos
completada
");
PolloAsado
worldSave
$*
Prueba_PR_Booleanos.ne
Propósito: Verificar reconocimiento de literales booleanas (On, Off)
Probar: Torch, And, Or, Not
Fecha: 28/04/2025
*$
$$ Prueba de literales booleanas en NotchEngine
$$ Verificando: On, Off
WorldName PruebaBooleanos:
Bedrock
Obsidian Torch VERDADERO On;
Obsidian Torch FALSO Off;
Inventory
$$ Declaración e inicialización con valores booleanos
Torch activo = On;
Torch inactivo = Off;
$$ Variables para almacenar resultados de operaciones lógicas
Torch resultado1;
Torch resultado2;
Torch resultado3;
Torch resultado4;
Torch resultado5;
SpawnPoint
PolloCrudo
$$ Mostrar valores booleanos directos
dropperSpider("
Valor
de
On
:
");
dropperTorch(On);
dropperSpider("
Valor
de
Off
:
");
dropperTorch(Off);
$$ Operaciones lógicas con literales booleanas
resultado1 = On and On;
dropperSpider("
On
and
On
:
");
dropperTorch(resultado1);
resultado2 = On and Off;
dropperSpider("
On
and
Off
:
");
dropperTorch(resultado2);
resultado3 = On or Off;
dropperSpider("
On
or
Off
:
");
dropperTorch(resultado3);
resultado4 = Off or Off;
dropperSpider("
Off
or
Off
:
");
dropperTorch(resultado4);
resultado5 = not On;
dropperSpider("
not
On
:
");
dropperTorch(resultado5);
$$ Uso en estructuras de control
target On craft hit
PolloCrudo
dropperSpider("
Condición
On
es
verdadera
");
PolloAsado
target Off craft hit
PolloCrudo
dropperSpider("
Esto
no
debería
mostrarse
");
PolloAsado
miss
PolloCrudo
dropperSpider("
Condición
Off
es
falsa
");
PolloAsado
PolloAsado
worldSave
$*
Prueba_PR_Bloques.ne
Propósito: Verificar reconocimiento de delimitadores de bloques (PolloCrudo, PolloAsado)
Probar: PolloCrudo, PolloAsado
Fecha: 28/04/2025
*$
$$ Prueba de delimitadores de bloques en NotchEngine
$$ Verificando: PolloCrudo, PolloAsado
WorldName PruebaBloques:
Inventory
$$ Variables para las pruebas
Stack contador = 0;
Stack acumulador = 0;
Stack resultado = 0;
Spider mensaje = "
Prueba
de
bloques
PolloCrudo
y
PolloAsado
";
CraftingTable
$$ Función con bloques de código
Spell sumarPares(Stack :: limite) -> Stack
PolloCrudo
Stack suma = 0;
$$ Bloque anidado dentro de una estructura de control
walk i set 1 to limite craft
PolloCrudo
target i % 2 is 0 craft hit
PolloCrudo
suma += i;
PolloAsado
PolloAsado
respawn suma;
PolloAsado
$$ Función con diferentes niveles de anidamiento de bloques
Spell calcularFactorial(Stack :: n) -> Stack
PolloCrudo
target n <= 1 craft hit
PolloCrudo
respawn 1;
PolloAsado
$$ Bloque dentro de una expresión
Stack resultado = n * calcularFactorial(n - 1);
respawn resultado;
PolloAsado
SpawnPoint
$$ Bloque principal
PolloCrudo
$$ Bloque simple
PolloCrudo
contador = 5;
dropperSpider(mensaje);
PolloAsado
$$ Bloque dentro de una estructura repeater
repeater contador > 0 craft
PolloCrudo
acumulador += contador;
magma contador;
$$ Bloque anidado dentro de un condicional dentro de un bucle
target contador is 2 craft hit
PolloCrudo
dropperSpider("
Contador
es
igual
a
2
");
$$ Otro bloque más anidado
PolloCrudo
dropperSpider("
Este
es
un
bloque
muy
anidado
");
PolloAsado
PolloAsado
PolloAsado
$$ Uso de bloques en estructura condicional
target acumulador > 10 craft hit
PolloCrudo
dropperSpider("
Acumulador
es
mayor
que
10
");
PolloAsado
miss
PolloCrudo
dropperSpider("
Acumulador
es
menor
o
igual
a
10
");
PolloAsado
$$ Bloque en estructura spawner-exhausted
spawner
PolloCrudo
soulsand resultado;
target resultado > 5 craft hit creeper;
PolloAsado
exhausted resultado > 10;
dropperSpider("
Valor
final
del
resultado
:
" bind resultado);
PolloAsado
worldSave
$*
Prueba_PR_Control.ne
Propósito: Verificar reconocimiento de palabras de control de flujo
Probar: Entity, PolloCrudo, PolloAsado, Punto, SpawnPoint, Inventory, WorldName
Fecha: 28/04/2025
*$
$$ Prueba de palabras reservadas de control de flujo en NotchEngine
$$ Verificando: repeater, craft, target, hit, miss, jukebox, disc, silence,
$$ spawner, exhausted, walk, set, to, step, wither
WorldName PruebaControl:
Inventory
$$ Variables para las pruebas
Stack contador = 0;
Stack opcion = 2;
Torch condicion = On;
Stack iterador = 0;
Entity Punto
PolloCrudo
Stack x;
Stack y;
PolloAsado;
Entity Punto coordenada;
SpawnPoint
PolloCrudo
$$ 1. Prueba de repeater (while) con craft
dropperSpider("
Prueba
de
repeater
:
");
contador = 5;
repeater contador > 0 craft
PolloCrudo
dropperStack(contador);
magma contador;
PolloAsado
$$ 2. Prueba de target (if) con hit y miss
dropperSpider("
Prueba
de
target
con
hit
y
miss
:
");
target condicion craft hit
PolloCrudo
dropperSpider("
Condición
es
verdadera
");
PolloAsado
miss
PolloCrudo
dropperSpider("
Condición
es
falsa
");
PolloAsado
$$ 3. Prueba de jukebox (switch) con disc y silence
dropperSpider("
Prueba
de
jukebox
con
disc
y
silence
:
");
jukebox opcion craft
disc 1:
PolloCrudo
dropperSpider("
Opción
1
seleccionada
");
PolloAsado
disc 2:
PolloCrudo
dropperSpider("
Opción
2
seleccionada
");
PolloAsado
silence:
PolloCrudo
dropperSpider("
Ninguna
opción
válida
seleccionada
");
PolloAsado
$$ 4. Prueba de spawner (do-while) con exhausted
dropperSpider("
Prueba
de
spawner
con
exhausted
:
");
contador = 0;
spawner
PolloCrudo
soulsand contador;
dropperStack(contador);
PolloAsado
exhausted contador >= 3;
$$ 5. Prueba de walk (for) con set, to, step
dropperSpider("
Prueba
de
walk
con
set
,
to
,
step
:
");
walk i set 0 to 10 step 2 craft
PolloCrudo
dropperStack(i);
PolloAsado
$$ 6. Prueba de wither (with)
dropperSpider("
Prueba
de
wither
:
");
coordenada@x = 10;
coordenada@y = 20;
wither coordenada craft
PolloCrudo
dropperSpider("
Coordenadas
:
(
" bind x bind "
,
" bind y bind "
)
");
PolloAsado
PolloAsado
worldSave
$*
Prueba_PR_Saltos.ne
Propósito: Verificar palabras para saltos y terminación (creeper, enderPearl, ragequit)
Fecha: 28/04/2025
*$
$$ Prueba de palabras reservadas para saltos y terminación en NotchEngine
$$ Verificando: creeper, enderPearl, ragequit
WorldName PruebaSaltos:
Inventory
$$ Variables para las pruebas
Stack contador = 0;
Stack totalPares = 0;
Stack totalImpares = 0;
Torch errorCritico = Off;
SpawnPoint
PolloCrudo
$$ 1. Prueba de creeper (break) para salir de un bucle
dropperSpider("
Prueba
de
creeper
(
break
)
:
");
walk i set 1 to 10 craft
PolloCrudo
dropperSpider("
Iteración
:
" bind i);
$$ Salimos del bucle cuando i llega a 5
target i is 5 craft hit
PolloCrudo
dropperSpider("
Encontrado
5
,
saliendo
del
bucle
con
creeper
");
creeper;
PolloAsado
PolloAsado
$$ 2. Prueba de enderPearl (continue) para saltar a la siguiente iteración
dropperSpider("
Prueba
de
enderPearl
(
continue
)
:
");
walk i set 1 to 10 craft
PolloCrudo
$$ Saltamos los números pares
target i % 2 is 0 craft hit
PolloCrudo
dropperSpider("
Número
par
" bind i bind "
,
saltando
con
enderPearl
");
enderPearl;
PolloAsado
$$ Esta parte solo se ejecuta para números impares
dropperSpider("
Procesando
número
impar
:
" bind i);
totalImpares += i;
PolloAsado
dropperSpider("
Total
de
números
impares
:
" bind totalImpares);
$$ 3. Prueba de creeper y enderPearl en bucles anidados
dropperSpider("
Prueba
de
control
de
flujo
en
bucles
anidados
:
");
walk i set 1 to 5 craft
PolloCrudo
walk j set 1 to 5 craft
PolloCrudo
$$ Saltar la iteración cuando j es 3
target j is 3 craft hit
PolloCrudo
dropperSpider("
Saltando
j
=
3
con
enderPearl
");
enderPearl;
PolloAsado
$$ Salir del bucle interno cuando j es 4
target j is 4 craft hit
PolloCrudo
dropperSpider("
Saliendo
del
bucle
interno
con
creeper
en
j
=
4
");
creeper;
PolloAsado
dropperSpider("
i
=
" bind i bind "
,
j
=
" bind j);
PolloAsado
PolloAsado
$$ 4. Prueba de ragequit (halt) para terminar el programa
$$ Nota: Esta parte debe estar comentada en pruebas reales
$$ o al final del programa, ya que detiene la ejecución
dropperSpider("
Prueba
de
ragequit
(
halt
)
:
");
target errorCritico craft hit
PolloCrudo
dropperSpider("
Error
crítico
detectado
,
terminando
programa
con
ragequit
");
$$ ragequit; $$ Comentado para evitar terminar la prueba
PolloAsado
dropperSpider("
Esta
línea
se
mostrará
si
errorCritico
es
Off
");
$$ Ejemplo descomentado pero que nunca se ejecutará
target Off craft hit
PolloCrudo
dropperSpider("
Esta
condición
nunca
se
cumple
");
ragequit;
PolloAsado
PolloAsado
worldSave
$*
Prueba_PR_Funciones.ne
Propósito: Verificar palabras para funciones y procedimientos (Spell, Ritual, respawn, ender_pearl)
Probar: Spell, Ritual, respawn, ender_pearl, crafting_table
Fecha: 28/04/2025
*$
$$ Prueba de palabras reservadas para funciones y procedimientos en NotchEngine
$$ Verificando: Spell, Ritual, respawn
WorldName PruebaFunciones:
$$ Sección de prototipos
Recipe
$$ Prototipos de funciones (Spell)
Spell sumar(Stack :: a, b) -> Stack;
Spell factorial(Stack :: n) -> Stack;
Spell esPar(Stack :: numero) -> Torch;
Spell sumarArreglo(Shelf[10] Stack :: numeros; Stack tamano) -> Stack;
$$ Prototipos de procedimientos (Ritual)
Ritual imprimirLinea(Spider :: texto);
Ritual mostrarResultado(Spider :: operacion; Stack valor);
Ritual imprimirArreglo(Shelf[10] Stack :: arr; Stack tamano);
$$ Sección de rutinas (implementación de funciones y procedimientos)
CraftingTable
$$ Funciones (Spell) con instrucción de retorno (respawn)
Spell sumar(Stack :: a, b) -> Stack
PolloCrudo
$$ Retorno con expresión simple
respawn a + b;
PolloAsado
Spell factorial(Stack :: n) -> Stack
PolloCrudo
$$ Retorno temprano con condición
target n <= 1 craft hit
PolloCrudo
respawn 1;
PolloAsado
$$ Retorno con expresión compleja y llamada recursiva
respawn n * factorial(n - 1);
PolloAsado
Spell esPar(Stack :: numero) -> Torch
PolloCrudo
target numero % 2 is 0 craft hit
PolloCrudo
respawn On;
PolloAsado
miss
PolloCrudo
respawn Off;
PolloAsado
PolloAsado
Spell sumarArreglo(Shelf[10] Stack :: numeros; Stack tamano) -> Stack
PolloCrudo
Stack suma = 0;
$$ Verificar parámetros
target tamano <= 0 craft hit
PolloCrudo
respawn 0; $$ Retorno temprano
PolloAsado
$$ Sumar elementos del arreglo
walk i set 0 to tamano - 1 craft
PolloCrudo
suma += numeros[i];
PolloAsado
respawn suma; $$ Retorno al final
PolloAsado
$$ Procedimientos (Ritual) con posibles retornos vacíos
Ritual imprimirLinea(Spider :: texto)
PolloCrudo
dropperSpider(texto);
dropperSpider("
--
--
--
--
--
--
--
--
--
--
--
--
");
PolloAsado
Ritual mostrarResultado(Spider :: operacion; Stack valor)
PolloCrudo
dropperSpider(operacion bind "
:
" bind valor);
$$ Retorno temprano sin valor
target valor < 0 craft hit
PolloCrudo
dropperSpider("
Valor
negativo
");
respawn; $$ Retorno vacío temprano
PolloAsado
dropperSpider("
Valor
válido
procesado
");
PolloAsado
Ritual imprimirArreglo(Shelf[10] Stack :: arr; Stack tamano)
PolloCrudo
target tamano <= 0 craft hit
PolloCrudo
dropperSpider("
Arreglo
vacío
");
respawn; $$ Retorno vacío temprano
PolloAsado
dropperSpider("
Elementos
del
arreglo
:
");
walk i set 0 to tamano - 1 craft
PolloCrudo
dropperStack(arr[i]);
PolloAsado
PolloAsado
$$ Punto de entrada con llamadas a funciones y procedimientos
SpawnPoint
PolloCrudo
$$ Declaración de variables
Stack a = 5;
Stack b = 7;
Stack resultado;
Shelf[10] Stack numeros;
$$ Inicializar arreglo
walk i set 0 to 9 craft
PolloCrudo
numeros[i] = i + 1;
PolloAsado
$$ Llamadas a funciones (invocación directa)
resultado = sumar(a, b);
dropperSpider("
Suma
:
" bind resultado);
resultado = factorial(5);
dropperSpider("
Factorial
de
5
:
" bind resultado);
Torch esPar5 = esPar(5);
dropperSpider("
Es
5
par
:
");
dropperTorch(esPar5);
resultado = sumarArreglo(numeros, 10);
dropperSpider("
Suma
del
arreglo
:
" bind resultado);
$$ Llamadas a procedimientos
imprimirLinea("
==
==
Resultados
de
pruebas
==
==
");
mostrarResultado("
Suma
de
5
y
7
", sumar(a, b));
mostrarResultado("
Valor
negativo
", -10);
imprimirArreglo(numeros, 5);
imprimirArreglo(numeros, 0);
PolloAsado
worldSave
$*
Prueba_PR_Operadores.ne
Propósito: Verificar operadores textuales reales en Notch Engine
Probar: soulsand, magma, and, or, not, xor, bind, #, from ##, except ##, seek,
add, drop, feed, map, biom, void, isEngraved, isInscribed, etchUp, etchDown,
unlock, lock, make, gather, forge, expand
Fecha: 28/04/2025
*$
WorldName PruebaOperadores:
Inventory {
Stack contador = 5; $$ Inicializa contador con 5
Torch condicion1 = On; $$ Condición 1 es verdadera
Torch condicion2 = Off; $$ Condición 2 es falsa
Torch resultado; $$ Variable para almacenar resultados booleanos
Spider texto1 = "
Notch
"; $$ Texto inicial "
Notch
"
Spider texto2 = "
Engine
"; $$ Texto inicial "
Engine
"
Spider textoCompleto; $$ Variable para texto combinado
Rune letra = 'a'; $$ Letra inicial 'a'
Rune letraMayuscula; $$ Variable para letra mayúscula
Chest conjunto1 = {: 1, 2, 3 :}; $$ Conjunto inicial con 1, 2, 3
Chest conjunto2 = {: 3, 4, 5 :}; $$ Conjunto inicial con 3, 4, 5
Chest conjuntoResultado; $$ Variable para resultado de conjuntos
Book archivo1 = {/ "
datos
.
txt
", 'E' /}; $$ Archivo para escritura "
datos
.
txt
"
Book archivo2 = {/ "
resultado
.
txt
", 'E' /}; $$ Archivo para escritura "
resultado
.
txt
"
Ghast flotante1 = 3.5; $$ Flotante inicial 3.5
Ghast flotante2 = 2.5; $$ Flotante inicial 2.5
Ghast resultadoFlotante; $$ Variable para resultado de operaciones flotantes
}
SpawnPoint {
PolloCrudo
$$ soulsand y magma
soulsand contador; $$ Aplica soulsand a contador
magma contador; $$ Aplica magma a contador
$$ and, or, not, xor
resultado = condicion1 and condicion2; $$ Resultado es verdadero si ambas condiciones son verdaderas
resultado = condicion1 or condicion2; $$ Resultado es verdadero si al menos una condición es verdadera
resultado = not condicion1; $$ Resultado es el opuesto de condicion1
resultado = condicion1 xor condicion2; $$ Resultado es verdadero si solo una condición es verdadera
$$ bind, #, from ##, except ##, seek
textoCompleto = bind(texto1, "
" bind texto2); $$ Combina texto1 y texto2 con un espacio
Stack longitud = #(textoCompleto); $$ Longitud de textoCompleto
Spider subcadena = from textoCompleto ## 0 ## 5; $$ Subcadena de textoCompleto desde 0 hasta 5
Spider sinNotch = except textoCompleto ## 0 ## 6; $$ Elimina caracteres de 0 a 6 en textoCompleto
Stack posicion = seek(textoCompleto, "
Engine
"); $$ Posición de "
Engine
" en textoCompleto
$$ isEngraved, isInscribed, etchUp, etchDown
Torch esLetra = isEngraved(letra); $$ Verifica si letra es una letra
Torch esDigito = isInscribed(letra); $$ Verifica si letra es un dígito
letraMayuscula = etchUp(letra); $$ Convierte letra a mayúscula
Rune letraMinuscula = etchDown(letraMayuscula); $$ Convierte letraMayuscula a minúscula
$$ Operaciones de conjuntos
add(conjunto1, 4); $$ Añade 4 a conjunto1
drop(conjunto1, 2); $$ Elimina 2 de conjunto1
conjuntoResultado = feed(conjunto1, conjunto2); $$ Intersección de conjunto1 y conjunto2
resultado = map(conjunto1, 3); $$ Verifica si 3 está en conjunto1
Torch conjuntoVacio = void(conjunto1); $$ Verifica si conjunto1 está vacío
$$ Operaciones de archivos
unlock(archivo1); $$ Abre archivo1 para escritura
forge(archivo1, "
Texto
de
prueba
"); $$ Escribe "
Texto
de
prueba
" en archivo1
lock(archivo1); $$ Cierra archivo1
Book nuevoArchivo = make({/ "
nuevo
.
txt
", 'E' /}); $$ Crea nuevo archivo "
nuevo
.
txt
"
forge(nuevoArchivo, "
Contenido
del
nuevo
archivo
"); $$ Escribe en nuevoArchivo
lock(nuevoArchivo); $$ Cierra nuevoArchivo
unlock(archivo1); $$ Abre archivo1
unlock(nuevoArchivo); $$ Abre nuevoArchivo
expand(archivo1, nuevoArchivo); $$ Expande archivo1 con contenido de nuevoArchivo
lock(archivo1); $$ Cierra archivo1
lock(nuevoArchivo); $$ Cierra nuevoArchivo
$$ Operadores de flotantes
resultadoFlotante = flotante1 :+ flotante2; $$ Suma de flotante1 y flotante2
resultadoFlotante = flotante1 :- flotante2; $$ Resta de flotante1 y flotante2
resultadoFlotante = flotante1 :* flotante2; $$ Multiplicación de flotante1 y flotante2
resultadoFlotante = flotante1 :// flotante2; $$ División de flotante1 y flotante2
resultadoFlotante = flotante1 :% flotante2; $$ Módulo de flotante1 y flotante2
PolloAsado
}
worldSave
$*
Prueba_Lit_Enteros.ne
Propósito: Verificar reconocimiento de literales enteros (positivos, negativos, cero)
Probar: Stack
Fecha: 28/04/2025
*$
$$ Prueba de literales enteros en NotchEngine
$$ Verificando: enteros positivos, negativos y cero
WorldName PruebaLitEnteros:
Bedrock
$$ Constantes enteras
Obsidian Stack CERO 0;
Obsidian Stack POSITIVO 42;
Obsidian Stack NEGATIVO -42;
Obsidian Stack MAX_VALOR 2147483647; $$ Valor máximo de 32 bits
Obsidian Stack MIN_VALOR -2147483648; $$ Valor mínimo de 32 bits
Inventory
$$ Variables con literales enteros
Stack cero = 0;
Stack uno = 1;
Stack diez = 10;
Stack cien = 100;
Stack mil = 1000;
Stack millon = 1000000;
$$ Enteros negativos
Stack negUno = -1;
Stack negDiez = -10;
Stack negCien = -100;
Stack negMil = -1000;
Stack negMillon = -1000000;
$$ Valor entero máximo y mínimo (aproximadamente)
Stack maxInt = 2147483647;
Stack minInt = -2147483648;
$$ Variables para resultados
Stack resultado = 0;
SpawnPoint
PolloCrudo
$$ Operaciones aritméticas con literales enteros directos
resultado = 5 + 3; $$ 8
dropperSpider("
5
+
3
=
" bind resultado);
resultado = 10 - 7; $$ 3
dropperSpider("
10
-
7
=
" bind resultado);
resultado = 6 * 4; $$ 24
dropperSpider("
6
*
4
=
" bind resultado);
resultado = 20 // 4; $$ 5
dropperSpider("
20
4
=
" bind resultado);
resultado = 17 % 5; $$ 2
dropperSpider("
17
%
5
=
" bind resultado);
$$ Uso de literales enteros en expresiones complejas
resultado = (5 + 3) * 2 - 4 // 2; $$ 16 - 2 = 14
dropperSpider("
(
5
+
3
)
*
2
-
4
2
=
" bind resultado);
$$ Operaciones con literales enteros negativos
resultado = -5 + 10; $$ 5
dropperSpider("
-
5
+
10
=
" bind resultado);
resultado = 5 + -10; $$ -5
dropperSpider("
5
+
-
10
=
" bind resultado);
resultado = -5 * -4; $$ 20
dropperSpider("
-
5
*
-
4
=
" bind resultado);
$$ Uso de literales enteros en estructuras de control
walk i set 1 to 5 craft
PolloCrudo
dropperSpider("
Iteración
:
" bind i);
PolloAsado
$$ Comparaciones con literales enteros
target 10 > 5 craft hit
PolloCrudo
dropperSpider("
10
es
mayor
que
5
");
PolloAsado
target 0 is 0 craft hit
PolloCrudo
dropperSpider("
0
es
igual
a
0
");
PolloAsado
target -10 < -5 craft hit
PolloCrudo
dropperSpider("
-
10
es
menor
que
-
5
");
PolloAsado
$$ Operaciones con valores extremos (cuidado con overflow)
dropperSpider("
Valor
máximo
de
entero
:
" bind maxInt);
dropperSpider("
Valor
mínimo
de
entero
:
" bind minInt);
$$ Verificación del cero
target 0 is cero craft hit
PolloCrudo
dropperSpider("
Ambas
representaciones
de
cero
son
iguales
");
PolloAsado
PolloAsado
worldSave
$*
Prueba_Lit_Flotantes.ne
Propósito: Verificar reconocimiento de números flotantes (con parte decimal, sin parte decimal, negativos)
Probar: Ghast
Fecha: 28/04/2025
*$
$$ Prueba de literales flotantes en NotchEngine
$$ Verificando: flotantes con parte decimal, sin parte decimal, y negativos
WorldName PruebaLitFlotantes:
Bedrock
$$ Constantes flotantes
Obsidian Ghast CERO_PUNTO_CERO 0.0;
Obsidian Ghast PI 3.14159;
Obsidian Ghast E 2.71828;
Obsidian Ghast NEG_PI -3.14159;
Obsidian Ghast GRAVEDAD -9.8;
Inventory
$$ Flotantes positivos con parte decimal
Ghast decimal1 = 0.5;
Ghast decimal2 = 1.25;
Ghast decimal3 = 3.14159;
Ghast decimal4 = 2.71828;
Ghast decimal5 = 123.456;
$$ Flotantes negativos con parte decimal
Ghast negDecimal1 = -0.5;
Ghast negDecimal2 = -1.25;
Ghast negDecimal3 = -3.14159;
Ghast negDecimal4 = -2.71828;
Ghast negDecimal5 = -123.456;
$$ Formas alternativas (punto al principio, sin parte decimal)
Ghast decimal6 = .5; $$ Sin cero al principio, comienza con punto
Ghast decimal7 = 5.; $$ Sin decimales, termina con punto
$$ Números con muchos decimales
Ghast precisionAlta = 1.123456789012345;
$$ Números muy pequeños y muy grandes
Ghast muyPequeno = 0.0000001;
Ghast muyGrande = 1000000.0;
$$ Variables para resultados
Ghast resultado = 0.0;
SpawnPoint
PolloCrudo
$$ Operaciones aritméticas con literales flotantes directos
resultado = 5.5 :+ 3.5; $$ 9.0
dropperSpider("
5.5
:
+
3.5
=
");
dropperGhast(resultado);
resultado = 10.75 :- 7.25; $$ 3.5
dropperSpider("
10.75
:
-
7.25
=
");
dropperGhast(resultado);
resultado = 6.5 :* 2.0; $$ 13.0
dropperSpider("
6.5
:
*
2.0
=
");
dropperGhast(resultado);
resultado = 20.0 :// 4.0; $$ 5.0
dropperSpider("
20.0
:
4.0
=
");
dropperGhast(resultado);
resultado = 7.5 :% 2.0; $$ 1.5
dropperSpider("
7.5
:
%
2.0
=
");
dropperGhast(resultado);
$$ Uso de notaciones decimales alternativas
resultado = .5 :+ 2.; $$ 0.5 + 2.0 = 2.5
dropperSpider("
.
5
:
+
2
.
=
");
dropperGhast(resultado);
$$ Operaciones con literales flotantes negativos
resultado = -5.5 :+ 10.0; $$ 4.5
dropperSpider("
-
5.5
:
+
10.0
=
");
dropperGhast(resultado);
resultado = 5.0 :+ -10.0; $$ -5.0
dropperSpider("
5.0
:
+
-
10.0
=
");
dropperGhast(resultado);
resultado = -5.0 :* -4.0; $$ 20.0
dropperSpider("
-
5.0
:
*
-
4.0
=
");
dropperGhast(resultado);
$$ Expresiones complejas con flotantes
resultado = (2.5 :+ 1.5) :* 3.0 :- 5.0 :// 2.0; $$ 12.0 - 2.5 = 9.5
dropperSpider("
(
2.5
:
+
1.5
)
:
*
3.0
:
-
5.0
:
2.0
=
");
dropperGhast(resultado);
$$ Comparaciones con flotantes
target 3.14 > 3.0 craft hit
PolloCrudo
dropperSpider("
3.14
es
mayor
que
3.0
");
PolloAsado
target 0.1 :+ 0.2 isNot 0.3 craft hit $$ Debido a errores de precisión en flotantes
PolloCrudo
dropperSpider("
0.1
+
0.2
no
es
exactamente
igual
a
0.3
(
error
de
precisión
)
");
dropperGhast(0.1 :+ 0.2);
PolloAsado
$$ Conversión y coherción de tipos
Stack entero = 3.14159 >> Stack; $$ Cohersión a entero (trunca a 3)
dropperSpider("
PI
truncado
a
entero
:
" bind entero);
$$ Mostrar valores con diferentes precisiones
dropperSpider("
Valor
de
PI
:
");
dropperGhast(PI);
dropperSpider("
Número
con
alta
precisión
:
");
dropperGhast(precisionAlta);
dropperSpider("
Número
muy
pequeño
:
");
dropperGhast(muyPequeno);
dropperSpider("
Número
muy
grande
:
");
dropperGhast(muyGrande);
PolloAsado
worldSave
$*
Prueba_Lit_Caracteres.ne
Propósito: Verificar reconocimiento de caracteres (letras, dígitos, símbolos, escapes)
Probar: Rune, dropperRune, dropperSpider, dropperTorch
Fecha: 28/04/2025
*$
$$ Prueba de literales de caracteres en NotchEngine
$$ Verificando: letras, dígitos, símbolos y secuencias de escape
WorldName PruebaLitCaracteres:
Bedrock
$$ Constantes de caracteres
Obsidian Rune LETRA_A 'A';
Obsidian Rune LETRA_Z 'Z';
Obsidian Rune DIGITO_0 '0';
Obsidian Rune DIGITO_9 '9';
Obsidian Rune NUEVA_LINEA '\n';
Obsidian Rune TABULACION '\t';
Inventory
$$ Letras mayúsculas
Rune letraA = 'A';
Rune letraB = 'B';
Rune letraC = 'C';
Rune letraZ = 'Z';
$$ Letras minúsculas
Rune letraMina = 'a';
Rune letraMinb = 'b';
Rune letraMinc = 'c';
Rune letraMinz = 'z';
$$ Dígitos
Rune digito0 = '0';
Rune digito1 = '1';
Rune digito5 = '5';
Rune digito9 = '9';
$$ Símbolos comunes
Rune simboloExclamacion = '!';
Rune simboloInterrogacion = '?';
Rune simboloArroba = '@';
Rune simboloNumeral = '#';
Rune simboloDolar = '$';
Rune simboloPorcentaje = '%';
Rune simboloAmpersand = '&';
Rune simboloAsterisco = '*';
Rune simboloParentesisIzq = '(';
Rune simboloParentesisDer = ')';
Rune simboloGuion = '-';
Rune simboloGuionBajo = '_';
Rune simboloIgual = '=';
Rune simboloMas = '+';
Rune simboloCorcheteIzq = '[';
Rune simboloCorcheteDer = ']';
Rune simboloLlaveIzq = '{';
Rune simboloLlaveDer = '}';
Rune simboloPuntoyComa = ';';
Rune simboloDosPuntos = ':';
Rune simboloComillaSimple = '\'';
Rune simboloComillaDoble = '"
';
Rune simboloBarra = '
';
Rune simboloBarraInversa = '
';
Rune simboloBarraVertical = '
';
Rune simboloComa = '
,
';
Rune simboloPunto = '
.
';
Rune simboloMenorQue = '
<
';
Rune simboloMayorQue = '
>
';
$$ Secuencias de escape
Rune escapeNuevaLinea = '
n
';
Rune escapeTabulacion = '
t
';
Rune escapeRetornoCarro = '
r
';
Rune escapeBarraInversa = '
';
Rune escapeComillaSimple = '
''
;
Rune
escapeComillaDoble
=
'\"'
;
SpawnPoint
PolloCrudo
dropperSpider
(
"Letras mayúsculas: "
)
;
dropperRune
(
letraA
)
;
dropperRune
(
letraB
)
;
dropperRune
(
letraC
)
;
dropperSpider
(
"Letras minúsculas: "
)
;
dropperRune
(
letraMina
)
;
dropperRune
(
letraMinb
)
;
dropperRune
(
letraMinc
)
;
dropperSpider
(
"Dígitos: "
)
;
dropperRune
(
digito0
)
;
dropperRune
(
digito1
)
;
dropperRune
(
digito5
)
;
dropperRune
(
digito9
)
;
dropperSpider
(
"Símbolos: "
)
;
dropperRune
(
simboloExclamacion
)
;
dropperRune
(
simboloInterrogacion
)
;
dropperRune
(
simboloArroba
)
;
dropperRune
(
simboloNumeral
)
;
Spider
texto
=
"NotchEngine"
;
Rune
primerCaracter
=
texto
[
0
]
;
Rune
ultimoCaracter
=
texto
[
10
]
;
dropperSpider
(
"Primer carácter de 'NotchEngine': "
)
;
dropperRune
(
primerCaracter
)
;
dropperSpider
(
"Último carácter de 'NotchEngine': "
)
;
dropperRune
(
ultimoCaracter
)
;
Rune
letraMinuscula
=
'a'
;
Rune
letraMayuscula
=
etchUp
(
letraMinuscula
)
;
dropperSpider
(
"Minúscula: "
)
;
dropperRune
(
letraMinuscula
)
;
dropperSpider
(
"Convertida a mayúscula: "
)
;
dropperRune
(
letraMayuscula
)
;
letraMinuscula
=
etchDown
(
letraMayuscula
)
;
dropperSpider
(
"Convertida nuevamente a minúscula: "
)
;
dropperRune
(
letraMinuscula
)
;
Torch
esLetra
=
isEngraved
(
'A'
)
;
Torch
esDigito
=
isInscribed
(
'5'
)
;
dropperSpider
(
"¿'A' es una letra? "
)
;
dropperTorch
(
esLetra
)
;
dropperSpider
(
"¿'5' es un dígito? "
)
;
dropperTorch
(
esDigito
)
;
esLetra
=
isEngraved
(
'7'
)
;
esDigito
=
isInscribed
(
'K'
)
;
dropperSpider
(
"¿'7' es una letra? "
)
;
dropperTorch
(
esLetra
)
;
dropperSpider
(
"¿'K' es un dígito? "
)
;
dropperTorch
(
esDigito
)
;
Stack
valorAsciiA
=
letraA
>
>
Stack
;
dropperSpider
(
"Valor ASCII de 'A': "
bind
valorAsciiA
)
;
PolloAsado
worldSave
WorldName
PruebaLitStrings
:
Bedrock
Obsidian
Spider
VACIO
""
;
Obsidian
Spider
ESPACIO
" "
;
Obsidian
Spider
SALUDO
"Hola Mundo"
;
Obsidian
Spider
CON_COMILLAS
"Este string tiene \"comillas\""
;
Obsidian
Spider
MULTILINEA
"Primera línea\nSegunda línea"
;
Inventory
Spider
cadenaVacia
=
""
;
Spider
espacioSimple
=
" "
;
Spider
cadenaSimple
=
"Texto simple"
;
Spider
conNumeros
=
"Notch Engine v1.0"
;
Spider
conSimbolos
=
"¡Hola, mundo! ¿Cómo estás?"
;
Spider
conCaracteresEspeciales
=
"#$%&/()=?¡"
;
Spider
conNuevaLinea
=
"Primera línea\nSegunda línea"
;
Spider
conTabulacion
=
"Columna1\tColumna2\tColumna3"
;
Spider
conRetornoCarro
=
"Texto con\rretorno de carro"
;
Spider
conBarraInversa
=
"Ruta de archivo: C:\\Archivos\\datos.txt"
;
Spider
conComillasSimples
=
"Texto con 'comillas simples'"
;
Spider
conComillasDobles
=
"Texto con \"comillas dobles\""
;
Spider
mixto
=
"Abc123!@#\n\t\"'"
;
Spider
cadenaLarga
=
"Esta es una cadena de texto más larga que contiene múltiples palabras, números como 12345, y símbolos como $%&. Es útil para probar el manejo de cadenas extensas en el analizador léxico y asegurarse de que no hay limitaciones inesperadas en la longitud de las cadenas."
;
Spider
prefijo
=
"Notch"
;
Spider
sufijo
=
"Engine"
;
Spider
resultado
;
SpawnPoint
PolloCrudo
dropperSpider
(
"Cadena simple: "
bind
cadenaSimple
)
;
dropperSpider
(
"Cadena con números: "
bind
conNumeros
)
;
dropperSpider
(
"Cadena con símbolos: "
bind
conSimbolos
)
;
resultado
=
bind
(
prefijo
,
" "
bind
sufijo
)
;
dropperSpider
(
"Concatenación: "
bind
resultado
)
;
Stack
longitud
=
#
(
resultado
)
;
dropperSpider
(
"Longitud de '"
bind
resultado
bind
"': "
bind
longitud
)
;
Spider
subcadena
=
from
resultado
#
#
0
#
#
5
;
dropperSpider
(
"Subcadena (0, 5): "
bind
subcadena
)
;
Spider
sinNotch
=
except
resultado
#
#
0
#
#
6
;
dropperSpider
(
"Sin los primeros 6 caracteres: "
bind
sinNotch
)
;
Stack
posicion
=
seek
(
resultado
,
"Engine"
)
;
dropperSpider
(
"Posición de 'Engine': "
bind
posicion
)
;
Rune
primerCaracter
=
resultado
[
0
]
;
dropperSpider
(
"Primer carácter: "
)
;
dropperRune
(
primerCaracter
)
;
Rune
ultimoCaracter
=
resultado
[
11
]
;
dropperSpider
(
"Último carácter: "
)
;
dropperRune
(
ultimoCaracter
)
;
dropperSpider
(
"Cadena con nueva línea:"
)
;
dropperSpider
(
conNuevaLinea
)
;
dropperSpider
(
"Cadena con tabulaciones:"
)
;
dropperSpider
(
conTabulacion
)
;
dropperSpider
(
"Cadena con comillas dobles:"
)
;
dropperSpider
(
conComillasDobles
)
;
dropperSpider
(
"Cadena larga:"
)
;
dropperSpider
(
cadenaLarga
)
;
target
cadenaVacia
is
""
craft
hit
PolloCrudo
dropperSpider
(
"La cadena está vacía"
)
;
PolloAsado
target
SALUDO
is
"Hola Mundo"
craft
hit
PolloCrudo
dropperSpider
(
"Las cadenas son iguales"
)
;
PolloAsado
PolloAsado
worldSave
WorldName
PruebaLitArreglos
:
Bedrock
Inventory
Shelf
[
5
]
Stack
numerosSimples
=
[
1
,
2
,
3
,
4
,
5
]
;
Shelf
[
3
]
Stack
numerosNegativos
=
[
-
10
,
-
20
,
-
30
]
;
Shelf
[
4
]
Stack
numerosMixtos
=
[
-
2
,
0
,
2
,
4
]
;
Shelf
[
1
]
Stack
unicoElemento
=
[
42
]
;
Shelf
[
0
]
Stack
arregloVacio
=
[
]
;
Shelf
[
5
]
Rune
vocales
=
[
'a'
,
'e'
,
'i'
,
'o'
,
'u'
]
;
Shelf
[
5
]
Rune
simbolos
=
[
'!'
,
'@'
,
'#'
,
'$'
,
'%'
]
;
Shelf
[
3
]
Spider
nombres
=
[
"Steve"
,
"Alex"
,
"Herobrine"
]
;
Shelf
[
4
]
Spider
diasSemana
=
[
"Lunes"
,
"Martes"
,
"Miércoles"
,
"Jueves"
]
;
Shelf
[
4
]
Torch
flags
=
[
On
,
Off
,
On
,
On
]
;
Shelf
[
3
]
Ghast
decimales
=
[
3.14
,
2.71
,
1.618
]
;
Shelf
[
3
]
Shelf
[
3
]
Stack
matriz
=
[
[
1
,
2
,
3
]
,
[
4
,
5
,
6
]
,
[
7
,
8
,
9
]
]
;
Shelf
[
2
]
Shelf
[
2
]
Shelf
[
2
]
Stack
cubo
=
[
[
[
1
,
2
]
,
[
3
,
4
]
]
,
[
[
5
,
6
]
,
[
7
,
8
]
]
]
;
Stack
suma
=
0
;
Stack
elementoActual
=
0
;
SpawnPoint
PolloCrudo
elementoActual
=
numerosSimples
[
0
]
;
dropperSpider
(
"Primer elemento del arreglo: "
bind
elementoActual
)
;
elementoActual
=
numerosSimples
[
4
]
;
dropperSpider
(
"Último elemento del arreglo: "
bind
elementoActual
)
;
numerosSimples
[
2
]
=
30
;
dropperSpider
(
"Elemento modificado: "
bind
numerosSimples
[
2
]
)
;
suma
=
0
;
walk
i
set
0
to
4
craft
PolloCrudo
suma
+
=
numerosSimples
[
i
]
;
dropperSpider
(
"Elemento "
bind
i
bind
": "
bind
numerosSimples
[
i
]
)
;
PolloAsado
dropperSpider
(
"Suma de todos los elementos: "
bind
suma
)
;
dropperSpider
(
"Vocales: "
)
;
walk
i
set
0
to
4
craft
PolloCrudo
dropperRune
(
vocales
[
i
]
)
;
PolloAsado
dropperSpider
(
"Nombres: "
)
;
walk
i
set
0
to
2
craft
PolloCrudo
dropperSpider
(
nombres
[
i
]
)
;
PolloAsado
dropperSpider
(
"Flags: "
)
;
walk
i
set
0
to
3
craft
PolloCrudo
dropperTorch
(
flags
[
i
]
)
;
PolloAsado
dropperSpider
(
"Decimales: "
)
;
walk
i
set
0
to
2
craft
PolloCrudo
dropperGhast
(
decimales
[
i
]
)
;
PolloAsado
elementoActual
=
matriz
[
1
]
[
1
]
;
dropperSpider
(
"Elemento central de la matriz: "
bind
elementoActual
)
;
matriz
[
0
]
[
2
]
=
10
;
dropperSpider
(
"Elemento modificado de la matriz: "
bind
matriz
[
0
]
[
2
]
)
;
dropperSpider
(
"Matriz completa:"
)
;
walk
i
set
0
to
2
craft
PolloCrudo
walk
j
set
0
to
2
craft
PolloCrudo
dropperStack
(
matriz
[
i
]
[
j
]
)
;
PolloAsado
dropperSpider
(
""
)
;
PolloAsado
elementoActual
=
cubo
[
1
]
[
0
]
[
1
]
;
dropperSpider
(
"Elemento de cubo [1][0][1]: "
bind
elementoActual
)
;
Shelf
[
4
]
Stack
fibonacci
=
[
1
,
1
,
2
,
3
]
;
dropperSpider
(
"Fibonacci: "
)
;
walk
i
set
0
to
3
craft
PolloCrudo
dropperStack
(
fibonacci
[
i
]
)
;
PolloAsado
PolloAsado
worldSave
WorldName
PruebaLitRegistros
:
Inventory
Entity
Jugador
PolloCrudo
Spider
nombre
;
Stack
nivel
;
Ghast
salud
;
Torch
activo
;
PolloAsado
;
Entity
Coordenada
PolloCrudo
Stack
x
;
Stack
y
;
Stack
z
;
PolloAsado
;
Entity
Configuracion
PolloCrudo
Torch
modoDebug
;
Stack
volumen
;
Spider
idioma
;
PolloAsado
;
Entity
Jugador
steve
=
{
nombre
:
"Steve"
,
nivel
:
1
,
salud
:
20.0
,
activo
:
On
}
;
Entity
Jugador
alex
=
{
nombre
:
"Alex"
,
nivel
:
2
,
salud
:
18.5
,
activo
:
On
}
;
Entity
Coordenada
posicion
=
{
x
:
10
,
y
:
20
,
z
:
30
}
;
Entity
Configuracion
config
=
{
modoDebug
:
Off
,
volumen
:
75
,
idioma
:
"Español"
}
;
Entity
Jugador
jugadorVacio
=
{
}
;
Entity
Coordenada
origen
=
{
x
:
0
}
;
Entity
Coordenada
punto
=
{
x
:
5
+
5
,
y
:
10
*
2
,
z
:
100
2
}
;
SpawnPoint
PolloCrudo
dropperSpider
(
steve
@
nombre
)
;
dropperStack
(
posicion
@
x
)
;
dropperTorch
(
config
@
modoDebug
)
;
steve
@
nivel
=
5
;
posicion
@
z
=
50
;
Stack
nivelTotal
=
steve
@
nivel
+
alex
@
nivel
;
dropperStack
(
nivelTotal
)
;
wither
steve
craft
PolloCrudo
dropperSpider
(
"Nombre: "
bind
nombre
)
;
dropperStack
(
nivel
)
;
dropperGhast
(
salud
)
;
PolloAsado
Entity
Jugador
herobrine
=
{
nombre
:
"Herobrine"
,
nivel
:
100
,
salud
:
1000.0
,
activo
:
On
}
;
Entity
Coordenada
pos2
=
{
x
:
100
,
y
:
200
,
z
:
300
}
;
PolloAsado
worldSave
WorldName
PruebaLitConjuntos
:
Inventory
Chest
numeros
=
{
:
1
,
2
,
3
,
4
,
5
:
}
;
Chest
primos
=
{
:
2
,
3
,
5
,
7
,
11
,
13
,
17
,
19
:
}
;
Chest
pares
=
{
:
2
,
4
,
6
,
8
,
10
:
}
;
Chest
vocales
=
{
:
'a'
,
'e'
,
'i'
,
'o'
,
'u'
:
}
;
Chest
consonantes
=
{
:
'b'
,
'c'
,
'd'
,
'f'
,
'g'
:
}
;
Chest
nombres
=
{
:
"Steve"
,
"Alex"
,
"Herobrine"
,
"Notch"
:
}
;
Chest
herramientas
=
{
:
"Espada"
,
"Pico"
,
"Hacha"
,
"Pala"
:
}
;
Chest
vacio
=
{
:
:
}
;
Chest
singleton
=
{
:
42
:
}
;
Chest
mezcla
=
{
:
1
,
'a'
,
"texto"
:
}
;
Chest
calculados
=
{
:
1
+
1
,
2
*
2
,
10
2
:
}
;
Chest
booleanos
=
{
:
On
,
Off
:
}
;
SpawnPoint
PolloCrudo
add
(
numeros
,
6
)
;
dropperSpider
(
"Después de add(numeros, 6):"
)
;
drop
(
primos
,
2
)
;
dropperSpider
(
"Después de drop(primos, 2):"
)
;
Chest
union
=
feed
(
numeros
,
primos
)
;
dropperSpider
(
"Unión de numeros y primos:"
)
;
Chest
interseccion
=
map
(
numeros
,
pares
)
;
dropperSpider
(
"Intersección de numeros y pares:"
)
;
Torch
contiene
=
biom
(
vocales
,
'a'
)
;
dropperTorch
(
contiene
)
;
Torch
esVacio
=
void
(
vacio
)
;
dropperTorch
(
esVacio
)
;
Chest
conEspacios
=
{
:
'a'
,
'b'
,
'c'
:
}
;
Chest
conComentarios
=
{
:
1
,
2
,
3
:
}
;
Chest
{
:
1
,
'x'
,
"y"
:
}
;
PolloAsado
worldSave
WorldName
PruebaLitArchivos
:
Inventory
Book
archivoConfiguracion
=
{
"config.txt"
,
'L'
}
;
Book
archivoJugadores
=
{
"jugadores.dat"
,
'L'
}
;
Book
archivoNiveles
=
{
"niveles/nivel1.map"
,
'L'
}
;
Book
archivoLog
=
{
"sistema.log"
,
'E'
}
;
Book
archivoResultados
=
{
"resultados.txt"
,
'E'
}
;
Book
archivoExportacion
=
{
"export/datos.csv"
,
'E'
}
;
Book
archivoPuntajes
=
{
"puntajes.dat"
,
'A'
}
;
Book
archivoInventario
=
{
"inventario.sav"
,
'A'
}
;
Book
archivoEspecial
=
{
"archivo con espacios.txt"
,
'L'
}
;
Book
archivoEspecial2
=
{
"datos_especiales-2023.dat"
,
'E'
}
;
Book
archivoRutaRelativa
=
{
"../datos/config.ini"
,
'L'
}
;
Book
archivoRutaAbsoluta
=
{
"C:/Notch/Engine/data.bin"
,
'E'
}
;
Book
archivoTexto
=
{
"readme.txt"
,
'L'
}
;
Book
archivoImagen
=
{
"textura.png"
,
'L'
}
;
Book
archivoJSON
=
{
"settings.json"
,
'A'
}
;
Book
archivoXML
=
{
"estructura.xml"
,
'A'
}
;
Book
conBarras
=
{
"dir/subdir/archivo.ext"
,
'L'
}
;
Book
conPuntos
=
{
"../../archivo.ext"
,
'E'
}
;
Book
espaciado1
=
{
"compacto.txt"
,
'L'
}
;
Book
espaciado2
=
{
"espacios.txt"
,
'E'
}
;
Book
comentado
=
{
"log.txt"
,
'L'
}
;
SpawnPoint
PolloCrudo
unlock
(
archivoLog
)
;
forge
(
archivoLog
,
"Entrada de log: Inicio de programa"
)
;
lock
(
archivoLog
)
;
Book
nuevoArchivo
=
make
(
{
"nuevo.txt"
,
'E'
}
)
;
unlock
(
archivoConfiguracion
)
;
Spider
contenido
=
gather
(
archivoConfiguracion
)
;
lock
(
archivoConfiguracion
)
;
expand
(
archivoLog
,
archivoResultados
)
;
Book
{
"sinVariable.txt"
,
'A'
}
;
Book
arch1
=
{
"uno.txt"
,
'L'
}
;
Book
arch2
=
{
"dos.txt"
,
'E'
}
;
Book
conComentarioMedio
=
{
"comentado.txt"
,
'A'
}
;
PolloAsado
worldSave
WorldName
PruebaOpAritmeticos
:
Inventory
Stack
a
=
10
;
Stack
b
=
3
;
Stack
c
;
Stack
resultado
;
SpawnPoint
PolloCrudo
c
=
a
+
b
;
dropperSpider
(
"Suma: "
bind
c
)
;
c
=
a
-
b
;
dropperSpider
(
"Resta: "
bind
c
)
;
c
=
a
*
b
;
dropperSpider
(
"Multiplicación: "
bind
c
)
;
c
=
a
b
;
dropperSpider
(
"División entera: "
bind
c
)
;
c
=
a
%
b
;
dropperSpider
(
"Módulo: "
bind
c
)
;
resultado
=
a
+
b
*
c
;
dropperSpider
(
"a + b * c = "
bind
resultado
)
;
resultado
=
(
a
+
b
)
*
c
;
dropperSpider
(
"(a + b) * c = "
bind
resultado
)
;
resultado
=
a
+
b
+
c
;
dropperSpider
(
"a + b + c = "
bind
resultado
)
;
resultado
=
a
*
b
c
+
a
-
b
;
dropperSpider
(
"a * b // c + a - b = "
bind
resultado
)
;
resultado
=
-
a
;
dropperSpider
(
"-a = "
bind
resultado
)
;
resultado
=
5
+
3
;
dropperSpider
(
"5 + 3 = "
bind
resultado
)
;
resultado
=
-
(
a
+
b
)
;
dropperSpider
(
"-(a + b) = "
bind
resultado
)
;
resultado
=
a
+
b
;
resultado
=
a
-
b
;
resultado
=
a
*
b
;
resultado
=
a
b
;
resultado
=
a
%
b
;
resultado
=
a
+
b
;
resultado
=
a
-
b
;
resultado
=
a
*
b
;
resultado
=
a
b
;
resultado
=
a
%
b
;
resultado
=
a
+
b
;
resultado
=
a
*
b
;
resultado
=
(
(
(
(
a
+
b
)
*
c
)
2
)
%
10
)
;
soulsand
a
;
resultado
=
a
+
b
;
magma
b
;
resultado
=
a
-
b
;
PolloAsado
worldSave
WorldName
PruebaOpFlotantes
:
Inventory
Ghast
x
=
10.5
;
Ghast
y
=
3.25
;
Ghast
z
;
Ghast
resultado
;
SpawnPoint
PolloCrudo
z
=
x
:
+
y
;
dropperSpider
(
"Suma flotante: "
bind
z
)
;
z
=
x
:
-
y
;
dropperSpider
(
"Resta flotante: "
bind
z
)
;
z
=
x
:
*
y
;
dropperSpider
(
"Multiplicación flotante: "
bind
z
)
;
z
=
x
:
y
;
dropperSpider
(
"División flotante: "
bind
z
)
;
z
=
x
:
%
y
;
dropperSpider
(
"Módulo flotante: "
bind
z
)
;
resultado
=
x
:
+
y
:
*
z
;
dropperSpider
(
"x :+ y :* z = "
bind
resultado
)
;
resultado
=
(
x
:
+
y
)
:
*
z
;
dropperSpider
(
"(x :+ y) :* z = "
bind
resultado
)
;
resultado
=
x
:
+
y
:
+
z
;
dropperSpider
(
"x :+ y :+ z = "
bind
resultado
)
;
resultado
=
x
:
*
y
:
z
:
+
x
:
-
y
;
dropperSpider
(
"x :* y :// z :+ x :- y = "
bind
resultado
)
;
resultado
=
-
x
;
dropperSpider
(
"-x = "
bind
resultado
)
;
resultado
=
5.5
:
+
3.2
;
dropperSpider
(
"5.5 :+ 3.2 = "
bind
resultado
)
;
resultado
=
-
(
x
:
+
y
)
;
dropperSpider
(
"-(x :+ y) = "
bind
resultado
)
;
resultado
=
x
:
+
y
;
resultado
=
x
:
-
y
;
resultado
=
x
:
*
y
;
resultado
=
x
:
y
;
resultado
=
x
:
%
y
;
resultado
=
x
:
+
y
;
resultado
=
x
:
-
y
;
resultado
=
x
:
*
y
;
resultado
=
x
:
y
;
resultado
=
x
:
%
y
;
resultado
=
x
:
+
y
;
resultado
=
x
:
*
y
;
resultado
=
(
(
(
(
x
:
+
y
)
:
*
z
)
:
2.0
)
:
%
10.0
)
;
Ghast
mezcla1
=
x
:
+
5
;
Ghast
mezcla2
=
3.5
:
*
y
;
Ghast
mezcla3
=
x
:
+
(
y
:
*
2.0
)
:
1.5
;
Spider
texto
=
"Notch:Engine"
;
Stack
entero
=
(
x
:
+
y
)
>
>
Stack
;
PolloAsado
worldSave
WorldName
PruebaOpComparacion
:
Inventory
Stack
a
=
10
;
Stack
b
=
5
;
Torch
resultado
;
Ghast
x
=
3.5
;
Ghast
y
=
2.75
;
Spider
cadena1
=
"abc"
;
Spider
cadena2
=
"def"
;
Rune
char1
=
'A'
;
Rune
char2
=
'B'
;
Torch
bool1
=
On
;
Torch
bool2
=
Off
;
SpawnPoint
PolloCrudo
resultado
=
a
<
b
;
dropperSpider
(
"a < b: "
bind
resultado
)
;
resultado
=
x
<
y
;
dropperSpider
(
"x < y: "
bind
resultado
)
;
resultado
=
cadena1
<
cadena2
;
dropperSpider
(
"cadena1 < cadena2: "
bind
resultado
)
;
resultado
=
char1
<
char2
;
dropperSpider
(
"char1 < char2: "
bind
resultado
)
;
resultado
=
a
>
b
;
dropperSpider
(
"a > b: "
bind
resultado
)
;
resultado
=
x
>
y
;
dropperSpider
(
"x > y: "
bind
resultado
)
;
resultado
=
a
<=
b
;
dropperSpider
(
"a <= b: "
bind
resultado
)
;
resultado
=
x
<=
y
;
dropperSpider
(
"x <= y: "
bind
resultado
)
;
resultado
=
a
>=
b
;
dropperSpider
(
"a >= b: "
bind
resultado
)
;
resultado
=
x
>=
y
;
dropperSpider
(
"x >= y: "
bind
resultado
)
;
resultado
=
a
is
b
;
dropperSpider
(
"a is b: "
bind
resultado
)
;
resultado
=
x
is
y
;
dropperSpider
(
"x is y: "
bind
resultado
)
;
resultado
=
cadena1
is
cadena2
;
dropperSpider
(
"cadena1 is cadena2: "
bind
resultado
)
;
resultado
=
bool1
is
bool2
;
dropperSpider
(
"bool1 is bool2: "
bind
resultado
)
;
resultado
=
a
isNot
b
;
dropperSpider
(
"a isNot b: "
bind
resultado
)
;
resultado
=
x
isNot
y
;
dropperSpider
(
"x isNot y: "
bind
resultado
)
;
resultado
=
cadena1
isNot
cadena2
;
dropperSpider
(
"cadena1 isNot cadena2: "
bind
resultado
)
;
resultado
=
bool1
isNot
bool2
;
dropperSpider
(
"bool1 isNot bool2: "
bind
resultado
)
;
resultado
=
a
<
b
;
resultado
=
a
>
b
;
resultado
=
a
<=
b
;
resultado
=
a
>=
b
;
resultado
=
aisb
;
resultado
=
a
is
b
;
resultado
=
aisNotb
;
resultado
=
a
isNot
b
;
resultado
=
a
<
b
;
resultado
=
a
>
b
;
resultado
=
a
<=
b
;
resultado
=
a
>=
b
;
resultado
=
a
is
b
;
resultado
=
a
isNot
b
;
target
a
<
b
craft
hit
PolloCrudo
dropperSpider
(
"a es menor que b"
)
;
PolloAsado
repeater
x
>
y
craft
PolloCrudo
dropperSpider
(
"x es mayor que y"
)
;
PolloAsado
resultado
=
(
a
+
b
)
>
(
x
:
+
y
)
;
resultado
=
a
*
2
<=
b
*
3
;
resultado
=
(
a
2
)
is
(
b
1
)
;
resultado
=
bind
(
cadena1
,
cadena2
)
isNot
"abcdef"
;
Spider
islandia
=
"país"
;
Stack
isNotacion
=
42
;
PolloAsado
worldSave
WorldName
PruebaOpAsignacion
:
Inventory
Stack
contador
=
10
;
Stack
acumulador
=
0
;
Ghast
decimal
=
5.5
;
Spider
texto
=
"Notch"
;
Shelf
[
5
]
Stack
arreglo
;
Entity
Punto
PolloCrudo
Stack
x
;
Stack
y
;
PolloAsado
;
Entity
Punto
punto
;
SpawnPoint
PolloCrudo
contador
=
5
;
dropperSpider
(
"Asignación simple: "
bind
contador
)
;
decimal
=
3.14
;
texto
=
"Engine"
;
contador
+
=
3
;
dropperSpider
(
"Asignación con suma: "
bind
contador
)
;
acumulador
=
0
;
acumulador
+
=
contador
;
acumulador
+
=
2
;
dropperSpider
(
"Acumulador después de += : "
bind
acumulador
)
;
contador
-
=
2
;
dropperSpider
(
"Asignación con resta: "
bind
contador
)
;
acumulador
=
20
;
acumulador
-
=
5
;
acumulador
-
=
contador
;
dropperSpider
(
"Acumulador después de -= : "
bind
acumulador
)
;
contador
*
=
3
;
dropperSpider
(
"Asignación con multiplicación: "
bind
contador
)
;
acumulador
=
2
;
acumulador
*
=
contador
;
dropperSpider
(
"Acumulador después de *= : "
bind
acumulador
)
;
contador
=
2
;
dropperSpider
(
"Asignación con división: "
bind
contador
)
;
acumulador
=
50
;
acumulador
=
5
;
dropperSpider
(
"Acumulador después de /= : "
bind
acumulador
)
;
contador
%
=
3
;
dropperSpider
(
"Asignación con módulo: "
bind
contador
)
;
acumulador
=
17
;
acumulador
%
=
5
;
dropperSpider
(
"Acumulador después de %= : "
bind
acumulador
)
;
arreglo
[
0
]
=
10
;
arreglo
[
1
]
=
20
;
arreglo
[
2
]
=
30
;
arreglo
[
0
]
+
=
5
;
dropperSpider
(
"arreglo[0] después de += : "
bind
arreglo
[
0
]
)
;
arreglo
[
1
]
-
=
5
;
dropperSpider
(
"arreglo[1] después de -= : "
bind
arreglo
[
1
]
)
;
arreglo
[
2
]
*
=
2
;
dropperSpider
(
"arreglo[2] después de *= : "
bind
arreglo
[
2
]
)
;
punto
@
x
=
10
;
punto
@
y
=
20
;
punto
@
x
+
=
5
;
dropperSpider
(
"punto@x después de += : "
bind
punto
@
x
)
;
punto
@
y
-
=
8
;
dropperSpider
(
"punto@y después de -= : "
bind
punto
@
y
)
;
contador
=
5
;
contador
+
=
3
;
contador
-
=
2
;
contador
*
=
4
;
contador
=
2
;
contador
%
=
3
;
contador
=
5
;
contador
+
=
3
;
contador
-
=
2
;
contador
*
=
4
;
contador
=
2
;
contador
%
=
3
;
contador
=
10
;
contador
+
=
5
;
Stack
a
=
1
,
b
=
2
,
c
=
3
;
contador
=
(
a
+
b
)
*
c
;
contador
+
=
a
*
b
;
contador
-
=
a
+
b
;
contador
*
=
(
a
*
2
)
+
(
b
*
3
)
;
contador
=
a
+
1
;
contador
%
=
b
*
2
;
a
=
10
;
b
=
20
;
c
=
30
;
Spider
igual_texto
=
"Este texto tiene un signo = dentro"
;
Spider
mas_texto
=
"Este texto tiene un signo + dentro"
;
Spider
menos_texto
=
"Este texto tiene un signo - dentro"
;
Spider
por_texto
=
"Este texto tiene un signo * dentro"
;
Spider
div_texto
=
"Este texto tiene un signo / dentro"
;
Spider
mod_texto
=
"Este texto tiene un signo % dentro"
;
PolloAsado
worldSave
WorldName
PruebaOpAcceso
:
Inventory
Shelf
[
5
]
Stack
numeros
;
Shelf
[
3
]
Shelf
[
3
]
matriz
;
Shelf
[
2
]
Shelf
[
2
]
Shelf
[
2
]
cubo
;
Spider
texto
=
"Notch Engine"
;
Entity
Punto
PolloCrudo
Stack
x
;
Stack
y
;
Stack
z
;
PolloAsado
;
Entity
Punto
punto
;
Entity
Persona
PolloCrudo
Spider
nombre
;
Stack
edad
;
Torch
activo
;
Shelf
[
3
]
Stack
notas
;
PolloAsado
;
Entity
Persona
estudiante
;
Shelf
[
3
]
Entity
Punto
puntos
;
Entity
Contenedor
PolloCrudo
Shelf
[
5
]
Stack
valores
;
Spider
etiqueta
;
PolloAsado
;
Entity
Contenedor
caja
;
SpawnPoint
PolloCrudo
numeros
[
0
]
=
10
;
numeros
[
1
]
=
20
;
numeros
[
2
]
=
30
;
Stack
valor
=
numeros
[
0
]
;
dropperSpider
(
"Valor en numeros[0]: "
bind
valor
)
;
Stack
indice
=
2
;
valor
=
numeros
[
indice
]
;
dropperSpider
(
"Valor en numeros[indice]: "
bind
valor
)
;
valor
=
numeros
[
1
+
1
]
;
dropperSpider
(
"Valor en numeros[1 + 1]: "
bind
valor
)
;
matriz
[
0
]
[
0
]
=
11
;
matriz
[
0
]
[
1
]
=
12
;
matriz
[
1
]
[
0
]
=
21
;
matriz
[
1
]
[
1
]
=
22
;
valor
=
matriz
[
1
]
[
1
]
;
dropperSpider
(
"Valor en matriz[1][1]: "
bind
valor
)
;
valor
=
matriz
[
indice
-
1
]
[
indice
-
1
]
;
dropperSpider
(
"Valor en matriz[indice - 1][indice - 1]: "
bind
valor
)
;
cubo
[
0
]
[
0
]
[
0
]
=
111
;
cubo
[
1
]
[
1
]
[
1
]
=
222
;
valor
=
cubo
[
1
]
[
1
]
[
1
]
;
dropperSpider
(
"Valor en cubo[1][1][1]: "
bind
valor
)
;
Rune
caracter
=
texto
[
0
]
;
dropperSpider
(
"Carácter en texto[0]: "
bind
caracter
)
;
caracter
=
texto
[
6
]
;
dropperSpider
(
"Carácter en texto[6]: "
bind
caracter
)
;
caracter
=
texto
[
indice
*
2
]
;
dropperSpider
(
"Carácter en texto[indice * 2]: "
bind
caracter
)
;
texto
[
0
]
=
'n'
;
dropperSpider
(
"Texto modificado: "
bind
texto
)
;
punto
@
x
=
10
;
punto
@
y
=
20
;
punto
@
z
=
30
;
valor
=
punto
@
x
;
dropperSpider
(
"Valor en punto@x: "
bind
valor
)
;
punto
@
y
=
punto
@
x
*
2
;
dropperSpider
(
"Valor en punto@y después de asignación: "
bind
punto
@
y
)
;
estudiante
@
nombre
=
"Steve"
;
estudiante
@
edad
=
25
;
estudiante
@
activo
=
On
;
estudiante
@
notas
[
0
]
=
85
;
estudiante
@
notas
[
1
]
=
90
;
estudiante
@
notas
[
2
]
=
95
;
Spider
nombre
=
estudiante
@
nombre
;
dropperSpider
(
"Nombre del estudiante: "
bind
nombre
)
;
Stack
nota
=
estudiante
@
notas
[
1
]
;
dropperSpider
(
"Segunda nota del estudiante: "
bind
nota
)
;
puntos
[
0
]
@
x
=
1
;
puntos
[
0
]
@
y
=
2
;
puntos
[
0
]
@
z
=
3
;
puntos
[
1
]
@
x
=
4
;
puntos
[
1
]
@
y
=
5
;
puntos
[
1
]
@
z
=
6
;
valor
=
puntos
[
1
]
@
y
;
dropperSpider
(
"Valor en puntos[1]@y: "
bind
valor
)
;
caja
@
etiqueta
=
"Items"
;
caja
@
valores
[
0
]
=
100
;
caja
@
valores
[
1
]
=
200
;
valor
=
caja
@
valores
[
1
]
;
dropperSpider
(
"Valor en caja@valores[1]: "
bind
valor
)
;
valor
=
numeros
[
0
]
;
nombre
=
estudiante
@
nombre
;
valor
=
numeros
[
0
]
;
valor
=
matriz
[
1
]
[
1
]
;
nombre
=
estudiante
@
nombre
;
valor
=
cubo
[
0
]
[
matriz
[
0
]
[
0
]
%
3
]
[
numeros
[
0
]
10
]
;
valor
=
numeros
[
0
]
;
nombre
=
estudiante
@
nombre
;
Spider
textoCuadrado
=
"Esto no es un [acceso]"
;
Spider
textoArroba
=
"Email: usuario@dominio.com"
;
PolloAsado
worldSave
WorldName
PruebaOpEspeciales
:
Bedrock
Obsidian
Stack
MAX_SIZE
1024
;
Inventory
Stack
entero
=
42
;
Ghast
flotante
=
3.14159
;
Spider
texto
=
"Notch Engine"
;
Rune
caracter
=
'A'
;
Torch
booleano
=
On
;
Shelf
[
5
]
Stack
arreglo
;
Chest
conjunto
=
{
:
1
,
2
,
3
:
}
;
Entity
Punto
PolloCrudo
Stack
x
;
Stack
y
;
PolloAsado
;
Entity
Punto
punto
;
SpawnPoint
PolloCrudo
Stack
tamanoStack
=
chunk
Stack
;
Stack
tamanoGhast
=
chunk
Ghast
;
Stack
tamanoSpider
=
chunk
Spider
;
Stack
tamanoRune
=
chunk
Rune
;
Stack
tamanoTorch
=
chunk
Torch
;
dropperSpider
(
"Tamaño de Stack en bytes: "
bind
tamanoStack
)
;
dropperSpider
(
"Tamaño de Ghast en bytes: "
bind
tamanoGhast
)
;
dropperSpider
(
"Tamaño de Spider en bytes: "
bind
tamanoSpider
)
;
dropperSpider
(
"Tamaño de Rune en bytes: "
bind
tamanoRune
)
;
dropperSpider
(
"Tamaño de Torch en bytes: "
bind
tamanoTorch
)
;
Stack
tamanoShelf
=
chunk
Shelf
[
5
]
Stack
;
Stack
tamanoChest
=
chunk
Chest
;
Stack
tamanoPunto
=
chunk
Punto
;
dropperSpider
(
"Tamaño de arreglo en bytes: "
bind
tamanoShelf
)
;
dropperSpider
(
"Tamaño de conjunto en bytes: "
bind
tamanoChest
)
;
dropperSpider
(
"Tamaño de Punto en bytes: "
bind
tamanoPunto
)
;
Stack
tamanoVariable
=
chunk
entero
;
Stack
tamanoArreglo
=
chunk
arreglo
;
Stack
tamanoTexto
=
chunk
texto
;
dropperSpider
(
"Tamaño de variable entero en bytes: "
bind
tamanoVariable
)
;
dropperSpider
(
"Tamaño de variable arreglo en bytes: "
bind
tamanoArreglo
)
;
dropperSpider
(
"Tamaño de variable texto en bytes: "
bind
tamanoTexto
)
;
Stack
tamanoExpresion
=
chunk
(
entero
*
2
+
10
)
;
dropperSpider
(
"Tamaño de expresión en bytes: "
bind
tamanoExpresion
)
;
Stack
enteroDeFlotante
=
flotante
>
>
Stack
;
dropperSpider
(
"Flotante convertido a entero: "
bind
enteroDeFlotante
)
;
Torch
booleanoDeEntero
=
entero
>
>
Torch
;
dropperSpider
(
"Entero convertido a booleano: "
bind
booleanoDeEntero
)
;
Rune
caracterDeTexto
=
texto
>
>
Rune
;
dropperSpider
(
"Primer carácter del texto: "
bind
caracterDeTexto
)
;
Stack
resultadoEntero
=
(
flotante
:
+
2.5
)
>
>
Stack
;
dropperSpider
(
"Suma flotante convertida a entero: "
bind
resultadoEntero
)
;
Stack
tam1
=
chunkStack
;
Stack
tam2
=
chunk
Stack
;
Stack
tam3
=
chunk
(
Stack
)
;
Stack
ent1
=
flotante
>
>
Stack
;
Stack
ent2
=
flotante
>
>
Stack
;
Stack
tam4
=
chunk
Stack
;
Stack
ent3
=
flotante
>
>
Stack
;
Stack
tam5
=
chunk
Stack
;
Stack
ent4
=
flotante
>
>
Stack
;
Stack
tamCombinado
=
chunk
(
flotante
>
>
Stack
)
;
Spider
textoMayor
=
"Esto no es una coherción >>"
;
Spider
textoChunk
=
"La palabra chunk no es un operador aquí"
;
Stack
resultado
=
(
flotante
:
*
2.0
>
>
Stack
)
+
(
entero
*
3
)
;
target
(
flotante
>
>
Stack
)
>
3
craft
hit
PolloCrudo
dropperSpider
(
"La parte entera de flotante es mayor que 3"
)
;
PolloAsado
PolloAsado
worldSave
WorldName
PruebaComLinea
:
Bedrock
Obsidian
Stack
MAX_LEVEL
100
;
Obsidian
Spider
VERSION
"1.0"
;
Inventory
Stack
contador
=
0
;
Spider
texto
=
"Notch Engine"
;
Rune
inicial
;
Stack
a
=
10
,
b
=
20
;
Recipe
Spell
calcular
(
Stack
::
a
,
b
)
->
Stack
;
CraftingTable
Spell
calcular
(
Stack
::
a
,
b
)
->
Stack
PolloCrudo
Stack
resultado
=
a
+
b
;
respawn
resultado
;
PolloAsado
Ritual
mostrarMensaje
(
Spider
::
mensaje
)
PolloCrudo
dropperSpider
(
mensaje
)
;
PolloAsado
SpawnPoint
PolloCrudo
contador
=
5
;
target
contador
>
0
craft
hit
PolloCrudo
dropperSpider
(
"Contador positivo"
)
;
PolloAsado
Stack
resultado
=
contador
+
10
;
Stack
suma
=
calcular
(
5
,
10
)
;
;
PolloAsado
worldSave
WorldName
PruebaComBloque
:
Bedrock
Obsidian
Stack
MAX_LEVEL
100
;
Obsidian
Spider
VERSION
"1.0"
;
Inventory
Stack
contador
=
0
;
Spider
texto
=
"Notch Engine"
;
Rune
inicial
;
Stack
a
=
10
,
b
=
20
;
Recipe
Spell
calcular
(
Stack
::
a
,
b
)
->
Stack
;
CraftingTable
Spell
calcular
(
Stack
::
a
,
b
)
->
Stack
PolloCrudo
Stack
resultado
=
a
+
b
;
respawn
resultado
;
PolloAsado
Ritual
mostrarMensaje
(
Spider
::
mensaje
)
PolloCrudo
dropperSpider
(
mensaje
)
;
PolloAsado
SpawnPoint
PolloCrudo
contador
=
5
+
10
;
target
contador
>
0
craft
hit
PolloCrudo
dropperSpider
(
"Contador positivo"
)
;
PolloAsado
dentro
pero
sin
cerrar
aún
*
secuencias
*
PolloAsado
worldSave
WorldName
PruebaComentarios
:
Inventory
Stack
contador
=
10
;
Spider
texto
=
"Comentario /* falso */ dentro de un string"
;
Rune
caracter
=
'*'
;
SpawnPoint
PolloCrudo
dropperSpider
(
"Los comentarios son importantes"
)
;
PolloAsado
worldSave
WorldName
PruebaIdentificadoresSimples
:
Bedrock
Obsidian
Stack
MAX
100
;
Obsidian
Spider
TITULO
"Notch Engine"
;
Inventory
Stack
a
;
Stack
contador
;
Stack
nivel
;
Stack
x
;
Stack
y
;
Stack
z
;
Stack
posicion
;
Stack
altura
;
Stack
ancho
;
Spider
nombre
;
Spider
texto
;
Spider
mensaje
;
Spider
saludo
;
Torch
activo
;
Torch
visible
;
Torch
terminado
;
Rune
inicial
;
Rune
caracter
;
Rune
simbolo
;
Ghast
pi
;
Ghast
temperatura
;
Ghast
velocidad
;
Stack
Contador
;
Spider
Nombre
;
Torch
Activo
;
Stack
i
;
Stack
j
;
Stack
k
;
Rune
c
;
Spider
s
;
Torch
b
;
Ghast
f
;
CraftingTable
Spell
suma
(
Stack
::
a
,
b
)
->
Stack
PolloCrudo
Stack
resultado
;
resultado
=
a
+
b
;
respawn
resultado
;
PolloAsado
Ritual
imprimir
(
Spider
::
mensaje
)
PolloCrudo
dropperSpider
(
mensaje
)
;
PolloAsado
SpawnPoint
PolloCrudo
Stack
valor
;
Stack
resultado
;
Spider
mensaje
;
valor
=
10
;
mensaje
=
"Hola"
;
resultado
=
valor
+
5
;
valor
=
suma
(
valor
,
20
)
;
ender_pearl
imprimir
(
mensaje
)
;
PolloAsado
worldSave
WorldName
PruebaIdentificadoresComplejos
:
Bedrock
Obsidian
Stack
MAX_LEVEL
100
;
Obsidian
Stack
MIN_LEVEL
1
;
Obsidian
Spider
GAME_TITLE
"Notch Engine"
;
Obsidian
Spider
VERSION_1_0
"v1.0"
;
Inventory
Stack
player_level
;
Stack
enemy_count
;
Stack
max_health
;
Stack
min_damage
;
Stack
current_position_x
;
Stack
counter1
;
Stack
item2
;
Stack
level3d
;
Stack
position2d
;
Stack
player1_health
;
Stack
item_1
;
Stack
player_2_score
;
Stack
enemy_level_3
;
Stack
position_x_1
;
Stack
inventory_slot_5
;
Stack
_temp
;
Stack
_internal_counter
;
Stack
_system_value
;
Stack
_player_data
;
Stack
very_long_variable_name_with_many_words
;
Spider
extremely_long_message_text_that_describes_something_in_detail
;
Torch
is_player_currently_in_creative_mode_with_flight_enabled
;
Stack
player5_current_health_max_100
;
Stack
enemy_3d_position_coordinate_x_12
;
Rune
player_initial_1
;
Spider
user_5_name
;
CraftingTable
Spell
calculate_total_damage
(
Stack
::
base_damage
,
critical_multiplier
;
Torch
::
is_headshot
)
->
Stack
PolloCrudo
Stack
total_damage
;
total_damage
=
base_damage
*
critical_multiplier
;
target
is_headshot
craft
hit
PolloCrudo
total_damage
=
total_damage
*
2
;
PolloAsado
respawn
total_damage
;
PolloAsado
Ritual
display_player_stats
(
Spider
::
player_name
;
Stack
level_1
,
health_points_100
)
PolloCrudo
dropperSpider
(
"Player: "
bind
player_name
)
;
dropperSpider
(
"Level: "
bind
level_1
)
;
dropperSpider
(
"Health: "
bind
health_points_100
)
;
PolloAsado
SpawnPoint
PolloCrudo
Stack
player1_health
=
100
;
Stack
enemy_count_5
=
10
;
Spider
main_player_name
=
"Steve_123"
;
player1_health
=
player1_health
-
20
;
enemy_count_5
=
calculate_total_damage
(
10
,
2
,
On
)
;
ender_pearl
display_player_stats
(
main_player_name
,
5
,
player1_health
)
;
Stack
___special_value
=
42
;
dropperStack
(
___special_value
)
;
PolloAsado
worldSave
WorldName
PruebaIdentificadoresSimilares
:
Bedrock
Obsidian
Stack
WorldNameTest
100
;
Obsidian
Spider
BedrockType
"Hard Stone"
;
Obsidian
Torch
InventoryFull
On
;
Inventory
Stack
worldname
;
Stack
WorldName2
;
Stack
bedrock
;
Stack
Bedrock_Type
;
Stack
inventory
;
Stack
InventorySlot
;
Stack
recipe
;
Stack
RecipeBook
;
Stack
craftingtable
;
Stack
CraftingTable2
;
Stack
spawnpoint
;
Stack
SpawnPoint_Main
;
Stack
stack
;
Spider
spider
;
Torch
torch
;
Rune
rune
;
Ghast
ghast
;
Chest
chest
;
Book
book
;
Stack
pollocrudo
;
Stack
PolloAsado
;
Stack
polloAsadoExtra
;
Stack
repeater
;
Stack
target
;
Stack
hit
;
Stack
miss
;
Stack
craft
;
Stack
jukebox
;
Stack
disc
;
Stack
silence
;
Stack
spawner
;
Stack
exhausted
;
Stack
walk
;
Stack
set
;
Stack
to
;
Stack
step
;
Stack
wither
;
Stack
creeper
;
Stack
enderPearl
;
Stack
enderpearlitem
;
Stack
ragequit
;
Stack
spell
;
Stack
Spell_Cast
;
Stack
ritual
;
Stack
RitualCeremony
;
Stack
respawn
;
Stack
respawnPoint
;
Stack
ender_pearl
;
Stack
enderpearlTeleport
;
Stack
soulsand
;
Stack
SoulSandBlock
;
Stack
magma
;
Stack
MagmaBlock
;
Stack
and
;
Stack
andOperator
;
Stack
or
;
Stack
orGate
;
Stack
not
;
Stack
notOperator
;
Stack
xor
;
Stack
xorCalculation
;
Stack
is
;
Stack
isNot
;
Stack
isEqual
;
Torch
on
;
Torch
onSwitch
;
Torch
off
;
Torch
offState
;
Stack
hopper
;
Stack
hopperMinecart
;
Stack
dropper
;
Stack
dropperFunction
;
CraftingTable
Spell
worldNameGenerator
(
)
->
Spider
PolloCrudo
Spider
spawnpoint
=
"DefaultSpawn"
;
Stack
craft
=
10
;
Spider
ritual
=
"Magic"
;
respawn
"Generated"
;
PolloAsado
Ritual
craftingTableMaker
(
Spider
::
recipe
;
Stack
inventory
)
PolloCrudo
Stack
spell
=
20
;
Stack
worldname
=
30
;
Torch
on
=
Off
;
dropperSpider
(
"Crafting table ready"
)
;
PolloAsado
SpawnPoint
PolloCrudo
Stack
worldname
=
1
;
Stack
bedrock
=
2
;
Stack
inventory
=
3
;
Stack
recipe
=
4
;
Stack
craftingtable
=
5
;
Stack
spawnpoint
=
6
;
worldname
=
worldname
+
bedrock
;
inventory
=
craftingtable
*
spawnpoint
;
target
worldname
>
recipe
craft
hit
PolloCrudo
Spider
spell
=
"Magic"
;
dropperSpider
(
spell
)
;
PolloAsado
Spider
generatedName
=
worldNameGenerator
(
)
;
ender_pearl
craftingTableMaker
(
"New Recipe"
,
inventory
)
;
PolloAsado
worldSave
WorldName
PruebaStringsLargos
:
Inventory
Spider
string_normal
=
"Este es un string normal"
;
Spider
string_largo
=
"Este es un string extremadamente largo para probar cómo maneja el analizador léxico los tokens de gran tamaño. El propósito es verificar si el buffer del analizador puede manejar correctamente cadenas que exceden el tamaño típico. En Minecraft, los jugadores pueden construir estructuras enormes y elaboradas, similar a cómo este string se extiende más allá de los límites normales. Las cadenas largas son útiles para almacenar textos extensos como descripciones, historias, o mensajes de diálogo en juegos. Este string sigue creciendo para asegurar que supere los límites habituales de procesamiento del analizador léxico."
;
Spider
string_muy_largo
=
"Este string es aún más largo que el anterior, llegando a aproximadamente mil caracteres para poner realmente a prueba los límites del analizador léxico. En el desarrollo de compiladores, es importante verificar cómo responde el sistema ante casos extremos. Los buffers mal dimensionados podrían causar desbordamientos o truncamientos inesperados. En el mundo de Minecraft, esto sería comparable a construir una megaestructura que se extiende hasta los límites permitidos del mundo. Es crucial que el compilador maneje correctamente estos casos límite, ya que en aplicaciones reales, los usuarios pueden introducir textos extremadamente largos, como documentación, logs detallados, o incluso código generado automáticamente. Este string continúa creciendo, añadiendo más y más caracteres para asegurar que pruebe adecuadamente la capacidad del buffer del analizador léxico. Una implementación robusta debería ser capaz de manejar este token sin problemas, reconociéndolo correctamente como un único string literal, sin importar su longitud. El tamaño máximo debería estar limitado únicamente por la memoria disponible en el sistema, no por limitaciones arbitrarias en el diseño del analizador léxico. Este string sigue y sigue, añadiendo más palabras y caracteres, para garantizar que realmente ponga a prueba los límites del analizador."
;
Spider
string_con_escapes
=
"Este string incluye secuencias de escape como: \n nueva línea, \t tabulación, \" comillas dobles, \\ barra invertida, y otros caracteres especiales como !@#$%^&*()_+-={}[]|:;<>,.?/~`"
;
Spider
string_multilinea
=
"Línea 1\nLínea 2\nLínea 3\nLínea 4\nLínea 5\nLínea 6\nLínea 7\nLínea 8\nLínea 9\nLínea 10\nLínea 11\nLínea 12\nLínea 13\nLínea 14\nLínea 15\nLínea 16\nLínea 17\nLínea 18\nLínea 19\nLínea 20"
;
Spider
string_simbolos
=
"Este string contiene símbolos que son tokens en Notch Engine: +, -, *, //, %, :+, :-, :*, :%, ://, @, [], {}, {: :}, {/ /}, >>. También incluye palabras reservadas como WorldName, Inventory, SpawnPoint, craft, respawn, soulsand, magma, etc."
;
Spider
string_extremo
=
"Este string es extremadamente largo AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA, superando los dos mil caracteres para realmente llevar al límite la capacidad del analizador léxico. En el desarrollo de compiladores e intérpretes, es fundamental probar cómo maneja el sistema casos extremos como este. Cualquier limitación no prevista en el diseño podría manifestarse al procesar tokens de este tamaño. En Minecraft, esto sería equivalente a construir una estructura colosal que se extiende por miles de bloques en todas direcciones, poniendo a prueba los límites del motor del juego. Los analizadores léxicos deben estar preparados para manejar tokens de cualquier longitud razonable, ya que en aplicaciones del mundo real, los usuarios pueden necesitar procesar textos extremadamente largos. Ejemplos incluyen el procesamiento de documentos completos, archivos de configuración extensos, o incluso código generado automáticamente que puede extenderse por miles de líneas. Este string sigue creciendo, añadiendo más y más palabras y caracteres, para asegurar que realmente ponga a prueba los límites del buffer del analizador. Una implementación robusta debería manejar este token sin problemas, reconociéndolo correctamente como un único string literal completo, sin importar su tamaño. El tamaño máximo debería estar limitado únicamente por la memoria disponible en el sistema, no por limitaciones arbitrarias en el diseño del analizador. Este string continúa expandiéndose, añadiendo más contenido para garantizar que supere cualquier buffer de tamaño fijo que pueda haber sido implementado. Es importante también verificar que el rendimiento del analizador no se degrade exponencialmente con tokens muy grandes, lo que podría indicar algoritmos ineficientes. En el contexto de Notch Engine, inspirado en Minecraft, este string sería como un libro dentro del juego con una historia increíblemente detallada que se extiende por múltiples páginas. El analizador léxico debe procesar este token de manera eficiente, reconociéndolo como un único string literal y no fragmentándolo incorrectamente en múltiples tokens. Este string sigue creciendo, agregando más y más caracteres, para asegurar que realmente ponga a prueba los límites del analizador léxico. Continúa expandiéndose, como un mundo de Minecraft que se genera infinitamente, añadiendo más palabras y frases para llegar a una longitud verdaderamente extrema. Este string sigue y sigue y sigue, desafiando las capacidades del analizador, probando su robustez y eficiencia al manejar casos extremos como este."
;
SpawnPoint
PolloCrudo
dropperSpider
(
"Prueba de strings largos completada"
)
;
Stack
longitud
=
#
(
string_largo
)
;
dropperStack
(
longitud
)
;
Spider
subcadena
=
from
string_largo
#
#
0
#
#
50
;
dropperSpider
(
subcadena
)
;
PolloAsado
worldSave
WorldName
PruebaNumeroGrande
:
Bedrock
Obsidian
Stack
NUM_PEQUENO
42
;
Obsidian
Stack
NUM_MEDIANO
12345
;
Obsidian
Stack
NUM_GRANDE
9876543210
;
Obsidian
Stack
NUM_MUY_GRANDE
1234567890123456789
;
Obsidian
Stack
NEG_PEQUENO
-
42
;
Obsidian
Stack
NEG_MEDIANO
-
12345
;
Obsidian
Stack
NEG_GRANDE
-
9876543210
;
Obsidian
Stack
NEG_MUY_GRANDE
-
1234567890123456789
;
Obsidian
Stack
INT_16BIT_MAX
32767
;
Obsidian
Stack
INT_16BIT_MIN
-
32768
;
Obsidian
Stack
INT_32BIT_MAX
2147483647
;
Obsidian
Stack
INT_32BIT_MIN
-
2147483648
;
Obsidian
Stack
INT_64BIT_MAX
9223372036854775807
;
Obsidian
Stack
INT_64BIT_MIN
-
9223372036854775808
;
Obsidian
Stack
NUM_EXTREMO
123456789012345678901234567890
;
Obsidian
Stack
NEG_EXTREMO
-
123456789012345678901234567890
;
Inventory
Stack
num1
=
1234567890
;
Stack
num2
=
9876543210
;
Stack
grande1
=
123456789012345678
;
Stack
grande2
=
987654321098765432
;
Stack
max16
=
32767
;
Stack
min16
=
-
32768
;
Stack
max32
=
2147483647
;
Stack
min32
=
-
2147483648
;
Stack
max64
=
9223372036854775807
;
Stack
min64
=
-
9223372036854775808
;
Stack
extremo
=
123456789012345678901234567890
;
Shelf
[
2147483647
]
Stack
arregloGrande
;
Stack
suma
;
Stack
resta
;
Stack
multiplicacion
;
Stack
division
;
Stack
modulo
;
SpawnPoint
PolloCrudo
suma
=
num1
+
num2
;
resta
=
num2
-
num1
;
multiplicacion
=
num1
*
10
;
division
=
num2
10
;
modulo
=
num2
%
10
;
Stack
resultado1
=
grande1
+
grande2
;
Stack
resultado2
=
extremo
1000
;
Stack
posible_overflow
=
max32
+
1
;
Stack
posible_underflow
=
min32
-
1
;
Stack
producto_grande
=
grande1
*
grande2
;
Stack
division_extrema
=
extremo
3
;
dropperStack
(
suma
)
;
dropperStack
(
resta
)
;
dropperStack
(
multiplicacion
)
;
dropperStack
(
division
)
;
target
producto_grande
>
0
craft
hit
PolloCrudo
dropperSpider
(
"El resultado es positivo"
)
;
PolloAsado
Stack
i
=
0
;
repeater
i
<
5
craft
PolloCrudo
dropperStack
(
i
)
;
dropperStack
(
grande1
)
;
soulsand
i
;
PolloAsado
PolloAsado
worldSave
WorldName
PruebaPrecisionFlotante
:
Bedrock
Obsidian
Ghast
PI_SIMPLE
3.14
;
Obsidian
Ghast
PI_PRECISO
3.14159265358979323846
;
Obsidian
Ghast
EULER
2.71828182845904523536
;
Obsidian
Ghast
RAIZ_DOS
1.41421356237309504880
;
Obsidian
Ghast
PHI
1.61803398874989484820
;
Obsidian
Ghast
SPEED_OF_LIGHT
2.99792458
e8
;
Obsidian
Ghast
PLANCK_CONSTANT
6.62607015
e
-
34
;
Obsidian
Ghast
AVOGADRO
6.02214076
e23
;
Obsidian
Ghast
EXTREMO_PEQUENO
0.0000000000000000000000001
;
Obsidian
Ghast
EXTREMO_GRANDE
123456789012345678901234.5678901234567890
;
Obsidian
Ghast
NEG_PI
-
3.14159265358979
;
Obsidian
Ghast
NEG_EXTREMO
-
0.0000000000000000000000001
;
Obsidian
Ghast
CERO_DECIMAL
0.0
;
Obsidian
Ghast
SOLO_ENTERO
42.0
;
Obsidian
Ghast
SOLO_DECIMAL
0.42
;
Obsidian
Ghast
PUNTO_INICIAL
.
5
;
Inventory
Ghast
normal
=
3.14
;
Ghast
preciso
=
3.141592653589793
;
Ghast
pequeno
=
0.000000000123
;
Ghast
grande
=
1234567890.123456789
;
Ghast
punto_inicial
=
.
25
;
Ghast
sin_decimal
=
42
.
;
Ghast
cientifico1
=
1.23
e5
;
Ghast
cientifico2
=
4.56
e
-
7
;
Ghast
cientifico3
=
7.89
e
+
12
;
Ghast
muy_pequeno
=
0.000000000000000000000000000000000001
;
Ghast
muy_grande
=
999999999999999999999999999999999999999.9
;
Ghast
muchos_digitos
=
123456789012345.678901234567890
;
Ghast
neg_normal
=
-
3.14
;
Ghast
neg_preciso
=
-
3.141592653589793
;
Ghast
neg_pequeno
=
-
0.000000000123
;
Ghast
neg_cientifico
=
-
2.998
e8
;
Ghast
resultado1
;
Ghast
resultado2
;
Ghast
resultado3
;
SpawnPoint
PolloCrudo
resultado1
=
normal
:
+
preciso
;
resultado2
=
preciso
:
-
normal
;
resultado3
=
normal
:
*
2.0
;
Ghast
res_extremo1
=
muy_pequeno
:
*
1000000.0
;
Ghast
res_extremo2
=
muy_grande
:
1000000.0
;
Ghast
division1
=
1.0
:
3.0
;
Ghast
division2
=
2.0
:
3.0
;
Ghast
division_extrema
=
1.0
:
9999999999.0
;
Ghast
res_cientifico
=
cientifico1
:
*
cientifico2
;
dropperGhast
(
resultado1
)
;
dropperGhast
(
resultado2
)
;
dropperGhast
(
division1
)
;
dropperGhast
(
division2
)
;
target
division1
:
<
0.34
craft
hit
PolloCrudo
dropperSpider
(
"La división 1/3 es menor que 0.34"
)
;
PolloAsado
Ghast
i
=
0.0
;
repeater
i
:
<
1.0
craft
PolloCrudo
dropperGhast
(
i
)
;
i
=
i
:
+
0.2
;
PolloAsado
PolloAsado
worldSave
WorldName
PruebaComentarioLargo
:
Inventory
Stack
contador
=
0
;
Stack
despues_comentario
=
1
;
Spider
mensaje
=
"Prueba de comentarios largos"
;
SpawnPoint
PolloCrudo
Stack
i
=
0
;
repeater
i
<
5
craft
PolloCrudo
soulsand
i
;
dropperSpider
(
mensaje
bind
" - iteración "
bind
i
)
;
PolloAsado
dropperSpider
(
"Prueba de comentarios largos completada"
)
;
PolloAsado
worldSave
WorldName
PruebaTokensConsecutivos
:
Bedrock
Obsidian
Stack
MAX_LEVEL5
100
;
Obsidian
Stack
LEVEL_PLUS_SKILL
200
;
Obsidian
Stack
OFFSET_MINUS_5
50
;
Inventory
Stack
a
=
5
;
Stack
b
=
10
;
Stack
c
=
a
+
b
;
Stack
suma
=
5
+
3
;
Stack
resta
=
10
-
7
;
Stack
multiplicacion
=
4
*
3
;
Stack
division
=
20
4
;
Stack
modulo
=
7
%
2
;
Torch
comparacion1
=
5
<
10
;
Torch
comparacion2
=
5
>
3
;
Torch
comparacion3
=
5
<=
5
;
Torch
comparacion4
=
5
>=
5
;
Torch
comparacion5
=
5
is5
;
Torch
comparacion6
=
5
isNot6
;
Stack
expr1
=
5
+
3
*
2
;
Stack
expr2
=
(
5
+
3
)
*
2
;
Stack
expr3
=
5
+
(
3
*
2
)
;
Ghast
f1
=
3.14
;
Ghast
f2
=
f1
:
+
2.5
;
Ghast
f3
=
f1
:
-
1.5
;
Ghast
f4
=
f1
:
*
2.0
;
Ghast
f5
=
f1
:
1.5
;
Shelf
[
5
]
Stack
arreglo
;
Entity
Jugador
PolloCrudo
Spider
nombre
;
Stack
nivel
;
PolloAsado
;
Spider
texto
=
"Hola"
;
Rune
caracter
=
'A'
;
Torch
booleano
=
On
;
Stack
arr
[
0
]
=
10
;
Stack
x
=
1
,
y
=
2
,
z
=
3
;
Stack
normal1
=
10
;
Stack
normal2
=
20
;
Spider
mensaje
=
"Tokens consecutivos"
;
SpawnPoint
PolloCrudo
suma
=
normal1
+
normal2
;
Stack
valor
=
(
normal1
+
5
)
*
(
normal2
-
5
)
;
repeater
suma
>
0
hit
PolloCrudo
suma
=
suma
-
1
;
dropperStack
(
suma
)
;
PolloAsado
target
valor
>=
100
hit
PolloCrudo
dropperSpider
(
"Valor grande"
)
;
PolloAsado
miss
PolloCrudo
dropperSpider
(
"Valor pequeño"
)
;
PolloAsado
dropperSpider
(
mensaje
)
;
dropperStack
(
valor
)
;
normal1
+
=
5
;
normal2
-
=
3
;
dropperStack
(
normal1
)
;
dropperStack
(
normal2
)
;
PolloAsado
worldSave
WorldName
PruebaCaracteresInvalidos
:
Bedrock
Obsidian
Stack
NORMAL
100
;
Obsidian
Stack
ÑANDU
200
;
Obsidian
Stack
AÇÚCAR
300
;
Obsidian
Stack
CAFÉ
400
;
Inventory
Stack
contador
=
0
;
Spider
mensaje
=
"Normal"
;
Stack
año
=
2025
;
Stack
piña
=
10
;
Spider
münzen
=
"Monedas"
;
Spider
öffentlich
=
"Público"
;
Stack
cont
ador
=
5
;
Spider
mens
aje
=
"Texto"
;
Stack
contador
=
10
;
Spider
mensaje
=
"Texto"
;
Stack
monedas
=
100
;
Stack
valor
=
50
;
Spider
texto
=
"Copyright"
;
Spider
texto_unicode
=
"Caracteres especiales: áéíóúñÁÉÍÓÚÑ"
;
Spider
texto_emoji
=
"Emojis: 😀🎮🌍💻"
;
Stack
a
b
;
Stack
c
d
;
Stack
e
f
;
Stack
g
h
;
Stack
valor
otro
;
Stack
valor
contador
=
5
;
Stack
otro
valor
=
10
;
Rune
char_1
=
'€'
;
Rune
char_2
=
'✓'
;
SpawnPoint
PolloCrudo
contador
=
1
;
contador
=
contador
2
;
contador
=
contador
2
;
dropperStack
(
año
)
;
dropperSpider
(
texto_unicode
)
;
contador
=
5
10
;
contador
=
5
10
;
contador
=
5
;
contador
=
contador
+
5
;
dropperSpider
(
"Fin de prueba"
)
;
PolloAsado
worldSave
WorldName
PruebaStringNoTerminado
:
Bedrock
Obsidian
Spider
NOMBRE
"Notch Engine"
;
Obsidian
Spider
VERSION
"1.0"
;
Obsidian
Spider
DESCRIPCION
"Un lenguaje basado en Minecraft;
$$ Constante después del error para verificar recuperación
Obsidian Stack MAX_NIVEL 100;
Inventory
$$ Variables con strings correctamente terminados
Spider normal = "
Este
string
está
bien
";
Spider multilinea = "
Este
string
tiene
nmúltiples
líneas
ny
está
bien
terminado
";
$$ Variable con string no terminado - falta comilla de cierre
Spider incompleto = "
Este
string
no
está
terminado
;
Stack
contador
=
0
;
Spider
confuso
=
"Este string tiene una comilla escapada \" pero no está terminado;
$$ String no terminado al final de una línea
Spider final_linea = "
Este
string
termina
la
línea
pero
no
está
cerrado
Spider
siguiente
=
"Este es un nuevo string"
;
Spider
combinado
=
"String no terminado Stack contador = 5;
$$ String con múltiples líneas pero sin terminar
Spider multilinea_incompleto = "
Este
string
tiene
múltiples
líneas
pero
no
está
terminado
correctamente
;
Spider
comentario_inmediato
=
"String terminado correctamente"
Spider
comentario_error
=
"String no terminado$$ Comentario que no salva el error
$$ String no terminado con comentario de bloque al final
Spider bloque_inmediato = "
String
no
terminado
Spider
consecutivo1
=
"Primer string terminado"
;
Spider
consecutivo2
=
"Segundo string no terminado;
Spider consecutivo3 = "
Tercer
string
terminado
";
SpawnPoint
PolloCrudo
$$ Código normal para contraste
dropperSpider("
Este
mensaje
está
bien
formado
");
$$ Instrucción con string no terminado
dropperSpider("
Este
mensaje
no
está
terminado
;
contador
=
1
;
Spider
resultado
=
normal
bind
"Parte no terminada;
$$ String no terminado en una estructura de control
target normal is "
Comparación
no
terminada
craft
hit
PolloCrudo
dropperSpider
(
"Este código nunca se ejecutará"
)
;
PolloAsado
dropperSpider
(
"String final no terminado
PolloAsado
worldSave
$*
Prueba_Err_ComentarioNoTerminado.ne
Propósito: Verificar detección de comentarios de bloque sin cierre
Fecha: 28/04/2025
*$
WorldName PruebaComentarioNoTerminado:
Bedrock
$$ Constantes normales para contraste
Obsidian Stack MAX_LEVEL 100;
$* Comentario de bloque correctamente cerrado *$
Obsidian Stack MIN_LEVEL 1;
$* Comentario de bloque sin cierre - falta el terminador *$
Obsidian Stack MEDIO_LEVEL 50;
Inventory
$$ Variables normales para contraste
Stack contador = 0;
Spider mensaje = "
Hola
Mundo
";
$*
Comentario de bloque multi-línea correctamente terminado
con varias líneas de texto
*$
Stack variable_normal = 5;
$*
Comentario de bloque multi-línea sin terminar
Este comentario no tiene el terminador correspondiente
y debería generar un error
Torch activo = On; $$ Esta línea no debería ser reconocida como código
Stack valor = 10; $$ Esta línea no debería ser reconocida como código
$$ Variables después del error para verificar recuperación
Stack recuperacion = 20;
$* Otro comentario no terminado
con símbolos que podrían confundir al analizador:
* asterisco suelto
$ signo dólar suelto
*$ esto parece un terminador pero no lo es
$* esto parece un iniciador dentro del comentario
$$ Más código después del segundo comentario no terminado
Torch otra_variable = Off;
$* Comentario aparentemente cerrado, pero con un espacio entre * y $
que debería causar que no se reconozca como terminador * $
$$ Código después del tercer comentario no terminado
Stack tercera_recuperacion = 30;
$*
Este comentario tiene una secuencia que parece un terminador,
pero tiene caracteres en medio: *texto$
Por lo tanto, no está realmente terminado.
$$ Último código para verificar recuperación
Stack ultima_recuperacion = 40;
SpawnPoint
PolloCrudo
$$ Código normal para contraste
dropperSpider("
Inicio
de
programa
");
$* Comentario de bloque sin terminar en el SpawnPoint
Esta sección del código no debería ejecutarse
contador = 5;
dropperStack(contador);
$$ Código después del comentario no terminado
Stack final = 100;
dropperStack(final);
dropperSpider("
Fin
de
programa
");
PolloAsado
$$ Esto debería ser código después del SpawnPoint, que no es válido
$$ pero el analizador léxico igual debería procesarlo como tokens
$*
Comentario final sin terminar
Este es el último elemento del archivo
worldSave
$*
Prueba: 37_Prueba_Err_CaracterNoTerminado
Descripción: Verificar detección de literales de carácter sin cierre
Fecha: 28/04/2025
*$
WorldName PruebaCaracterNoTerminado:
Inventory
$$ Casos de caracteres correctamente formados (para comparación)
Rune letraCorrecta = 'A';
Rune digitoCorrecto = '5';
Rune simboloCorrecto = '@';
Rune escapeCorrecto = '\n';
$$ Casos de caracteres sin cierre (errores léxicos)
Rune errorSimple = 'B; $$ Falta comilla de cierre
Rune errorEscape = '\n; $$ Falta comilla de cierre después de secuencia de escape
$$ Caso con apertura pero sin contenido ni cierre
Rune errorVacio = '; $$ Solo comilla de apertura
$$ Caso con múltiples caracteres (error léxico)
Rune errorMultiple = 'ABC; $$ Múltiples caracteres y falta comilla de cierre
$$ Error dentro de una expresión
Stack valor = 5 + (3 * 'x); $$ Falta comilla de cierre en la expresión
SpawnPoint
PolloCrudo
$$ Este carácter inválido debería ser detectado
Rune pruebaError = 'Z;
dropperSpider("
Este
texto
no
debería
ser
alcanzado
debido
al
error
léxico
");
PolloAsado
worldSave
$*
Prueba: 38_Prueba_Err_SimboloDesconocido
Descripción: Verificar detección de símbolos no reconocidos
Fecha: 28/04/2025
*$
WorldName PruebaSimboloDesconocido:
Bedrock
$$ Símbolos válidos para comparación
Obsidian Stack MAX_VALUE 100;
$$ Símbolo no reconocido: flecha de asignación errónea
Obsidian Stack MIN_VALUE => 0; $$ => no es un símbolo válido
Inventory
$$ Símbolos válidos (para comparación)
Stack contador = 10;
Stack resultado = contador + 5;
$$ Símbolos no reconocidos
Stack valor1 = 5 ^ 2; $$ ^ (potencia) no es un símbolo válido
Stack valor2 = 10 \ 3; $$ \ no es un operador válido
Stack valor3 = valor1 ~ valor2; $$ ~ no es un operador válido
$$ Operadores malformados o incompletos
Stack valor4 = 3 : 4; $$ : solo no es un operador válido (debe ser :+, :-, etc.)
Stack valor5 = 7 / 2; $$ / no es válido (debe ser // para división entera)
$$ Uso de símbolos de otros lenguajes
Stack valor6 = 5 ** 2; $$ ** (potencia en Python) no es válido
Torch condicion = (valor5 == valor6); $$ == no es válido (debe ser 'is')
$$ Símbolo inválido en acceso a estructura
Stack elemento = numeros->0; $$ -> no es válido para acceso (debe ser [])
ResourcePack
$$ Símbolo inválido en declaración de tipo
Anvil Stack ==> Spider; $$ ==> no es un símbolo válido (debe ser ->)
SpawnPoint
PolloCrudo
$$ Operadores inválidos en expresiones
Stack a = 5;
Stack b = 10;
Stack c = a ||| b; $$ ||| no es un operador válido
$$ Símbolos inválidos en estructuras de control
target a < b craft hit
PolloCrudo
dropperSpider("
a
es
menor
que
b
");
PolloAsado
?> $$ ?> no es un símbolo válido
$$ Símbolo inválido como terminador de instrucción
Stack valor = 100#
PolloAsado
worldSave
$*
Prueba: 39_Prueba_Comb_Estructura
Descripción: Verificar estructura básica de un programa completo
Fecha: 28/04/2025
*$
WorldName PruebaEstructuraCompleta:
$$ Sección de constantes
Bedrock
Obsidian Stack MAX_NIVEL 100;
Obsidian Spider VERSION "
1.0
.
0
";
Obsidian Torch DEBUG_MODE Off;
Obsidian Ghast PI 3.14159;
$$ Sección de tipos
ResourcePack
Anvil Ghast -> Stack truncate;
Anvil Stack -> Spider;
$$ Definición de un tipo personalizado
Entity Jugador
PolloCrudo
Spider nombre;
Stack nivel;
Ghast salud;
Torch activo;
PolloAsado;
$$ Sección de variables
Inventory
$$ Variables básicas
Stack contador = 0;
Spider mensaje = "
Bienvenido
a
Notch
Engine
";
Torch juego_activo = On;
Ghast temperatura = 21.5;
Chest letras = {: 'a', 'b', 'c' :};
$$ Variables compuestas
Shelf[5] Stack inventario;
Entity Jugador steve;
$$ Sección de prototipos
Recipe
$$ Prototipo de función
Spell calcularDanio(Stack :: nivel, arma; Ghast ref multiplicador) -> Stack;
$$ Prototipo de procedimiento
Ritual mostrarEstado(Spider :: nombre; Stack nivel, salud);
$$ Sección de implementación de rutinas
CraftingTable
$$ Implementación de función
Spell calcularDanio(Stack :: nivel, arma; Ghast ref multiplicador) -> Stack
PolloCrudo
Stack danio_base = nivel * 2;
target arma is 1 hit
PolloCrudo
danio_base *= 2; $$ Arma mejorada
PolloAsado
multiplicador = 1.5; $$ Modificar parámetro por referencia
respawn danio_base;
PolloAsado
$$ Implementación de procedimiento
Ritual mostrarEstado(Spider :: nombre; Stack nivel, salud)
PolloCrudo
dropperSpider("
==
==
=
Estado
del
Jugador
==
==
=
");
dropperSpider("
Nombre
:
" bind nombre);
dropperSpider("
Nivel
:
" bind nivel);
dropperSpider("
Salud
:
" bind salud);
dropperSpider("
==
==
==
==
==
==
==
==
==
==
==
==
==
==
=
");
PolloAsado
$$ Punto de entrada del programa
SpawnPoint
PolloCrudo
$$ Inicialización
steve@nombre = "
Steve
";
steve@nivel = 1;
steve@salud = 20.0;
steve@activo = On;
$$ Entrada y salida
dropperSpider(mensaje);
dropperSpider("
Ingrese
su
nombre
:
");
Spider nombre_jugador = hopperSpider();
$$ Uso de estructuras de control
target #(nombre_jugador) > 0 hit
PolloCrudo
dropperSpider("
Hola
,
" bind nombre_jugador bind "
");
$$ Uso de funciones y procedimientos
Stack danio = calcularDanio(steve@nivel, 1, 1.0);
dropperSpider("
Tu
daño
base
es
:
" bind danio);
ender_pearl mostrarEstado(steve@nombre, steve@nivel, steve@salud);
$$ Bucle
repeater juego_activo
PolloCrudo
dropperSpider("
Continuar
jugando
(
On
Off
)
");
juego_activo = hopperTorch();
target juego_activo hit
PolloCrudo
soulsand steve@nivel;
dropperSpider("
Nivel
aumentado
a
:
" bind steve@nivel);
PolloAsado
PolloAsado
PolloAsado
miss
PolloCrudo
dropperSpider("
Nombre
no
válido
.
");
PolloAsado
$$ Otros tipos de bucles
Stack i = 0;
spawner
PolloCrudo
soulsand i;
inventario[i] = i * 10;
PolloAsado
exhausted i >= 5;
walk j set 0 to 4
PolloCrudo
dropperSpider("
Inventario
[
" bind j bind "
]
:
" bind inventario[j]);
PolloAsado
PolloAsado
worldSave
$*
Prueba: 40_Prueba_Comb_Declaraciones
Descripción: Verificar combinaciones de declaraciones de variables y constantes
Fecha: 28/04/2025
*$
WorldName PruebaCombinacionDeclaraciones:
$$ Sección de constantes con diferentes tipos y complejidades
Bedrock
$$ Constantes simples de tipos básicos
Obsidian Stack MAX_PLAYERS 8;
Obsidian Stack MIN_LEVEL 1;
Obsidian Torch DEBUG_MODE On;
Obsidian Spider GAME_TITLE "
Notch
Engine
";
Obsidian Rune SEPARATOR '_';
Obsidian Ghast GRAVITY 9.8;
$$ Constantes con expresiones
Obsidian Stack MAX_INVENTORY_SIZE 5 * 9;
Obsidian Stack TOTAL_SLOTS MAX_PLAYERS * MAX_INVENTORY_SIZE;
Obsidian Spider FULL_TITLE GAME_TITLE bind "
v1
.
0
";
Obsidian Ghast TERMINAL_VELOCITY GRAVITY :* 3.0;
$$ Constantes con expresiones más complejas
Obsidian Stack DAYS_IN_YEAR 365;
Obsidian Stack DAYS_IN_4_YEARS DAYS_IN_YEAR * 4 + 1;
Obsidian Torch IS_LEAP_YEAR (DAYS_IN_4_YEARS - (DAYS_IN_YEAR * 4)) is 1;
$$ Declaraciones de tipos con diferentes formas
ResourcePack
$$ Conversiones de tipos básicas
Anvil Ghast -> Stack;
Anvil Ghast -> Stack truncate;
Anvil Stack -> Spider;
Anvil Rune -> Stack safe;
$$ Declaraciones de entidades (registros)
Entity Item
PolloCrudo
Spider nombre;
Stack cantidad;
Stack durabilidad;
Torch stackeable;
PolloAsado;
Entity Jugador
PolloCrudo
Spider nombre;
Stack nivel;
Stack experiencia;
Ghast salud;
Ghast hambre;
Torch en_linea;
Entity Item item_principal;
PolloAsado;
Entity Posicion
PolloCrudo
Stack x;
Stack y;
Stack z;
PolloAsado;
$$ Tipos anidados
Entity Mundo
PolloCrudo
Spider nombre;
Stack seed;
Shelf[10] Entity Jugador jugadores;
Entity Posicion spawn;
PolloAsado;
$$ Sección de variables con diferentes formas de declaración e inicialización
Inventory
$$ Declaraciones simples sin inicialización
Stack contador;
Spider mensaje;
Torch estado;
Rune inicial;
Ghast temperatura;
$$ Declaraciones con inicialización
Stack nivel = 1;
Spider nombre = "
Steve
";
Torch activo = On;
Rune tecla = 'A';
Ghast pi = 3.14159;
$$ Declaraciones múltiples del mismo tipo
Stack x = 0, y = 0, z = 0;
Torch jugando = On, pausa = Off, sonido = On;
Ghast distancia = 0.0, velocidad = 5.0, aceleracion = 1.5;
$$ Declaraciones con resultados de expresiones
Stack suma = 5 + 10;
Stack producto = 4 * 25;
Spider saludo = "
Hola
" bind nombre;
Torch condicion = nivel > 5;
Ghast promedio = (10.5 :+ 20.7 :+ 15.3) :// 3.0;
$$ Declaraciones de tipos compuestos
Shelf[5] Stack inventario;
Shelf[3] Spider mensajes = ["
Hola
", "
Mundo
", "
"];
Shelf[2] Shelf[2] Stack matriz;
Chest numeros = {: 1, 2, 3, 4, 5 :};
Book archivo = {/ "
datos
.
txt
", 'E' /};
$$ Instancias de entidades (registros)
Entity Item espada;
Entity Jugador jugador1
PolloCrudo
nombre: "
Alex
";
nivel: 5;
experiencia: 150;
salud: 18.5;
hambre: 16.0;
en_linea: On;
item_principal:
PolloCrudo
nombre: "
Espada
de
diamante
";
cantidad: 1;
durabilidad: 1500;
stackeable: Off;
PolloAsado;
PolloAsado;
Entity Mundo mundo_principal;
SpawnPoint
PolloCrudo
$$ Inicialización de variables declaradas sin valor inicial
contador = 0;
mensaje = "
Variable
inicializada
en
el
punto
de
entrada
";
estado = Off;
inicial = 'Z';
temperatura = 22.5;
$$ Inicialización de variables compuestas
espada@nombre = "
Espada
de
hierro
";
espada@cantidad = 1;
espada@durabilidad = 250;
espada@stackeable = Off;
matriz[0][0] = 1;
matriz[0][1] = 2;
matriz[1][0] = 3;
matriz[1][1] = 4;
mundo_principal@nombre = "
Mundo
de
prueba
";
mundo_principal@seed = 12345;
mundo_principal@spawn@x = 0;
mundo_principal@spawn@y = 64;
mundo_principal@spawn@z = 0;
$$ Uso de constantes en asignaciones
Stack max_jugadores = MAX_PLAYERS;
dropperSpider(FULL_TITLE);
$$ Uso de referencias a variables en asignaciones
Stack total = nivel + jugador1@nivel;
dropperSpider("
Nivel
total
:
" bind total);
PolloAsado
worldSave
$*
Prueba: 41_Prueba_Comb_Expresiones
Descripción: Verificar expresiones aritméticas y lógicas complejas
Fecha: 28/04/2025
*$
WorldName PruebaExpresionesComplejas:
Bedrock
Obsidian Stack BASE_DAMAGE 10;
Obsidian Stack ARMOR_FACTOR 2;
Obsidian Ghast CRIT_MULTIPLIER 1.5;
Obsidian Torch USE_ADVANCED_FORMULAS On;
Inventory
$$ Variables para las pruebas
Stack a = 5;
Stack b = 10;
Stack c = 15;
Stack resultado_entero;
Ghast x = 2.5;
Ghast y = 3.7;
Ghast z = 1.2;
Ghast resultado_flotante;
Torch p = On;
Torch q = Off;
Torch r = On;
Torch resultado_logico;
Spider str1 = "
Notch
";
Spider str2 = "
Engine
";
Spider resultado_string;
Shelf[5] Stack valores = [10, 20, 30, 40, 50];
Entity Jugador
PolloCrudo
Spider nombre;
Stack nivel;
Ghast salud;
PolloAsado;
Entity Jugador jugador;
SpawnPoint
PolloCrudo
$$ 1. Expresiones aritméticas complejas con enteros
resultado_entero = a + b * c;
dropperSpider("
a
+
b
*
c
=
" bind resultado_entero);
resultado_entero = (a + b) * c;
dropperSpider("
(
a
+
b
)
*
c
=
" bind resultado_entero);
resultado_entero = a + b - c * 2 // 3 % 4;
dropperSpider("
a
+
b
-
c
*
2
3
%
4
=
" bind resultado_entero);
resultado_entero = (a + (b - (c * (2 // (3 % 4)))));
dropperSpider("
Anidada
enteros
:
" bind resultado_entero);
soulsand a;
resultado_entero = a + b;
magma b;
dropperSpider("
Después
de
incremento
decremento
:
" bind resultado_entero);
$$ 2. Expresiones aritméticas complejas con flotantes
resultado_flotante = x :+ y :* z;
dropperSpider("
x
:
+
y
:
*
z
=
" bind resultado_flotante);
resultado_flotante = (x :+ y) :* z;
dropperSpider("
(
x
:
+
y
)
:
*
z
=
" bind resultado_flotante);
resultado_flotante = x :+ y :- z :* 2.0 :// 0.5 :% 1.0;
dropperSpider("
x
:
+
y
:
-
z
:
*
2.0
:
0.5
:
%
1.0
=
" bind resultado_flotante);
resultado_flotante = (x :+ (y :- (z :* (2.0 :// (0.5 :% 1.0)))));
dropperSpider("
Anidada
flotantes
:
" bind resultado_flotante);
$$ 3. Expresiones lógicas complejas
resultado_logico = p and q;
dropperSpider("
p
and
q
=
" bind resultado_logico);
resultado_logico = p or q;
dropperSpider("
p
or
q
=
" bind resultado_logico);
resultado_logico = not p;
dropperSpider("
not
p
=
" bind resultado_logico);
resultado_logico = p xor q;
dropperSpider("
p
xor
q
=
" bind resultado_logico);
resultado_logico = p and q or r;
dropperSpider("
p
and
q
or
r
=
" bind resultado_logico);
resultado_logico = p and (q or r);
dropperSpider("
p
and
(
q
or
r
)
=
" bind resultado_logico);
resultado_logico = not (p and q) or (not r and p);
dropperSpider("
not
(
p
and
q
)
or
(
not
r
and
p
)
=
" bind resultado_logico);
$$ 4. Expresiones de comparación
resultado_logico = a < b;
dropperSpider("
a
<
b
=
" bind resultado_logico);
resultado_logico = a > c;
dropperSpider("
a
>
c
=
" bind resultado_logico);
resultado_logico = a <= b and b >= c;
dropperSpider("
a
<=
b
and
b
>=
c
=
" bind resultado_logico);
resultado_logico = (a is b) or (b is c);
dropperSpider("
(
a
is
b
)
or
(
b
is
c
)
=
" bind resultado_logico);
resultado_logico = a isNot b and b isNot c and a isNot c;
dropperSpider("
a
isNot
b
and
b
isNot
c
and
a
isNot
c
=
" bind resultado_logico);
$$ 5. Expresiones mixtas (combinando tipos)
resultado_logico = (a + b > c) and (x :+ y :> z);
dropperSpider("
(
a
+
b
>
c
)
and
(
x
:
+
y
:
>
z
)
=
" bind resultado_logico);
resultado_logico = (a < b) or (not p) and (x :< y);
dropperSpider("
(
a
<
b
)
or
(
not
p
)
and
(
x
:
<
y
)
=
" bind resultado_logico);
$$ 6. Expresiones con operaciones de cadenas
resultado_string = bind(str1, "
" bind str2);
dropperSpider("
bind
result
:
" bind resultado_string);
Stack longitud = #(resultado_string);
dropperSpider("
Length
:
" bind longitud);
resultado_string = from resultado_string ## 0 ## 5;
dropperSpider("
Substring
:
" bind resultado_string);
Stack pos = seek(resultado_string, "
tch
");
dropperSpider("
Position
of
'tch'
:
" bind pos);
$$ 7. Expresiones con accesos a estructuras
Stack valor_arreglo = valores[2] + valores[3] * valores[4];
dropperSpider("
Array
expression
:
" bind valor_arreglo);
jugador@nombre = "
Steve
";
jugador@nivel = 20;
jugador@salud = 18.5;
Stack nivel_con_bonus = jugador@nivel + 5;
dropperSpider("
Nivel
con
bonus
:
" bind nivel_con_bonus);
Torch nivel_alto = jugador@nivel > 15 and jugador@salud :> 15.0;
dropperSpider("
Nivel
alto
:
" bind nivel_alto);
$$ 8. Expresiones con conversiones de tipo
Stack entero_desde_float = x >> Stack;
dropperSpider("
Entero
desde
float
:
" bind entero_desde_float);
Torch bool_desde_entero = a >> Torch;
dropperSpider("
Booleano
desde
entero
:
" bind bool_desde_entero);
$$ 9. Expresiones extremadamente complejas que combinan múltiples elementos
Stack damage = BASE_DAMAGE + ((jugador@nivel // 2) * (valores[1] + valores[3] // 3));
dropperSpider("
Daño
calculado
:
" bind damage);
target USE_ADVANCED_FORMULAS craft hit
PolloCrudo
Ghast damage_final = ((damage >> Ghast) :* CRIT_MULTIPLIER) :// (1.0 :+ ((valores[4] // 10) >> Ghast));
dropperSpider("
Daño
final
(
fórmula
avanzada
)
:
" bind damage_final);
PolloAsado
miss
PolloCrudo
Stack damage_simple = damage * 2 // (ARMOR_FACTOR + (p and q >> Stack));
dropperSpider("
Daño
final
(
fórmula
simple
)
:
" bind damage_simple);
PolloAsado
PolloAsado
worldSave
$*
Prueba: 42_Prueba_Comb_Control.ne
Descripción: Verificar estructuras de control anidadas
Fecha: 28/04/2025
*$
WorldName PruebaControlAnidado:
Inventory
$$ Variables para las pruebas
Stack contador = 0;
Stack max_iteraciones = 5;
Stack resultado = 0;
Stack opcion = 2;
Torch condicion1 = On;
Torch condicion2 = Off;
Spider mensaje = "
Estructuras
de
control
anidadas
";
Spider resultado_texto = "
";
Shelf[5] Stack matriz = [1, 2, 3, 4, 5];
Entity Personaje
PolloCrudo
Spider nombre;
Stack nivel;
Torch activo;
PolloAsado;
Entity Personaje jugador;
SpawnPoint
dropperSpider(mensaje);
jugador@nombre = "
Steve
";
jugador@nivel = 1;
jugador@activo = On;
$$ 1. Condicionales anidados (if-then-else)
target jugador@nivel >= 1 craft hit
PolloCrudo
dropperSpider("
Nivel
suficiente
para
comenzar
");
target jugador@activo craft hit
PolloCrudo
dropperSpider("
Jugador
activo
");
target jugador@nombre is "
Steve
" craft hit
PolloCrudo
dropperSpider("
Bienvenido
,
Steve
");
soulsand jugador@nivel;
PolloAsado
miss
PolloCrudo
dropperSpider("
Bienvenido
,
jugador
desconocido
");
PolloAsado
PolloAsado
miss
PolloCrudo
dropperSpider("
Jugador
inactivo
.
Activando
.
.
.
");
jugador@activo = On;
PolloAsado
PolloAsado
miss
PolloCrudo
dropperSpider("
Nivel
insuficiente
para
comenzar
");
PolloAsado
$$ 2. Switch anidado dentro de if
target opcion > 0 craft hit
PolloCrudo
jukebox opcion craft
disc 1:
PolloCrudo
dropperSpider("
Opción
1
seleccionada
");
target condicion1 craft hit
PolloCrudo
dropperSpider("
Subopción
A
");
PolloAsado
miss
PolloCrudo
dropperSpider("
Subopción
B
");
PolloAsado
PolloAsado
disc 2:
PolloCrudo
dropperSpider("
Opción
2
seleccionada
");
jukebox jugador@nivel craft
disc 1:
PolloCrudo
dropperSpider("
Nivel
básico
");
PolloAsado
disc 2:
PolloCrudo
dropperSpider("
Nivel
intermedio
");
PolloAsado
silence:
PolloCrudo
dropperSpider("
Nivel
desconocido
");
PolloAsado
PolloAsado
silence:
PolloCrudo
dropperSpider("
Opción
no
reconocida
");
PolloAsado
PolloAsado
$$ 3. Bucles anidados - while dentro de for
walk i set 0 to 2 craft
PolloCrudo
dropperSpider("
Iteración
de
for
principal
:
" bind i);
Stack j = 0;
repeater j < 3 craft
PolloCrudo
dropperSpider("
Subiteración
de
while
:
" bind j);
resultado += (i * 10 + j);
soulsand j;
PolloAsado
PolloAsado
dropperSpider("
Resultado
acumulado
:
" bind resultado);
$$ 4. Bucle do-while con if anidado
contador = 0;
resultado = 0;
spawner
PolloCrudo
soulsand contador;
dropperSpider("
Iteración
do
-
while
:
" bind contador);
target contador % 2 is 0 craft hit
PolloCrudo
dropperSpider("
Número
par
detectado
");
resultado += contador;
PolloAsado
miss
PolloCrudo
dropperSpider("
Número
impar
detectado
");
resultado += contador * 2;
PolloAsado
PolloAsado
exhausted contador >= max_iteraciones;
dropperSpider("
Resultado
tras
do
-
while
:
" bind resultado);
$$ 5. Bucles for anidados con break y continue
resultado = 0;
walk i set 0 to 5 craft
PolloCrudo
target i is 3 craft hit
PolloCrudo
dropperSpider("
Saltando
iteración
i
=
3
");
enderPearl;
PolloAsado
dropperSpider("
For
externo
:
" bind i);
walk j set 0 to 3 craft
PolloCrudo
target i is 4 and j > 1 craft hit
PolloCrudo
dropperSpider("
Terminando
loop
interno
en
i
=
4
,
j
=
" bind j);
creeper;
PolloAsado
resultado += (i + j);
dropperSpider("
For
interno
:
j
=
" bind j bind "
,
suma
acumulada
=
" bind resultado);
PolloAsado
PolloAsado
$$ 6. Combinación compleja: with dentro de if-else dentro de while
contador = 0;
resultado = 0;
repeater contador < 3 craft
PolloCrudo
soulsand contador;
dropperSpider("
Iteración
while
principal
:
" bind contador);
target contador % 2 is 0 craft hit
PolloCrudo
wither jugador craft
PolloCrudo
activo = Off;
dropperSpider("
" bind nombre bind "
desactivado
temporalmente
");
spawner
PolloCrudo
soulsand nivel;
dropperSpider("
Incrementando
nivel
:
" bind nivel);
PolloAsado
exhausted nivel > contador + 2;
activo = On;
dropperSpider("
" bind nombre bind "
reactivado
con
nivel
" bind nivel);
PolloAsado
PolloAsado
miss
PolloCrudo
Stack temp_nivel = jugador@nivel;
repeater temp_nivel > 0 craft
PolloCrudo
dropperSpider("
Reduciendo
nivel
temporal
:
" bind temp_nivel);
target temp_nivel is 1 craft hit
PolloCrudo
dropperSpider("
Nivel
mínimo
alcanzado
");
creeper;
PolloAsado
magma temp_nivel;
PolloAsado
PolloAsado
PolloAsado
$$ 7. Estructuras de control con expresiones complejas en las condiciones
walk i set 0 to matriz[2] + matriz[4] // 2 craft
PolloCrudo
target (i * 2 <= matriz[i % 5]) and ((i % 2 is 0) or (i is matriz[0])) craft hit
PolloCrudo
dropperSpider("
Condición
compleja
satisfecha
en
i
=
" bind i);
resultado += i;
PolloAsado
PolloAsado
dropperSpider("
Resultado
final
:
" bind resultado);
$$ 8. Instrucción ragequit condicionada anidada
target contador >= max_iteraciones and resultado < 100 craft hit
PolloCrudo
target jugador@nivel < 5 craft hit
PolloCrudo
dropperSpider("
Condiciones
críticas
alcanzadas
.
Terminando
programa
.
");
ragequit;
PolloAsado
PolloAsado
dropperSpider("
Programa
completado
con
éxito
.
");
worldSave
$*
Prueba: 43_Prueba_Rend_MuchosTokens
Descripción: Verificar rendimiento con un archivo con miles de tokens
Fecha: 28/04/2025
*$
WorldName PruebaMuchosTokens:
Bedrock
Obsidian Stack MAX_ITERATIONS 1000;
Obsidian Stack ARRAY_SIZE 500;
Obsidian Stack STEP_VALUE 1;
Obsidian Spider TEST_NAME "
Prueba
de
rendimiento
con
muchos
tokens
";
ResourcePack
Entity TestData
PolloCrudo
Stack id;
Stack value;
Ghast weight;
Spider name;
Torch active;
PolloAsado;
Inventory
$$ Declaramos variables extensas para generar muchos tokens
Shelf[500] Stack numbers;
$$ Creamos un array grande de registros
Shelf[100] Entity TestData records;
$$ Variables para el procesamiento
Stack counter;
Stack sum;
Stack product;
Stack max_value;
Stack min_value;
Ghast average;
Stack i;
Stack j;
Stack k;
Stack temp;
Torch condition;
SpawnPoint
dropperSpider(TEST_NAME);
dropperSpider("
Inicializando
arrays
.
.
.
");
$$ Inicialización masiva del array de enteros
walk i set 0 to ARRAY_SIZE - 1 craft
PolloCrudo
numbers[i] = i * STEP_VALUE;
PolloAsado
$$ Inicialización del array de registros
walk i set 0 to 99 craft
PolloCrudo
records[i]@id = i;
records[i]@value = i * 10;
records[i]@weight = i :* 0.5;
records[i]@name = "
Item_
" bind i;
records[i]@active = i % 2 is 0;
PolloAsado
dropperSpider("
Realizando
cálculos
.
.
.
");
$$ Cálculos repetitivos generando miles de tokens
sum = 0;
product = 1;
max_value = numbers[0];
min_value = numbers[0];
$$ Bucle con muchas operaciones
walk i set 0 to ARRAY_SIZE - 1 craft
PolloCrudo
$$ Acumuladores simples
sum += numbers[i];
$$ Para evitar overflow, sólo multiplicamos los primeros 10 valores
target i < 10 craft hit
PolloCrudo
product *= numbers[i] + 1;
PolloAsado
$$ Cálculo de máximo y mínimo
target numbers[i] > max_value craft hit
PolloCrudo
max_value = numbers[i];
PolloAsado
target numbers[i] < min_value craft hit
PolloCrudo
min_value = numbers[i];
PolloAsado
$$ Operaciones condicionales adicionales
target i % 50 is 0 craft hit
PolloCrudo
dropperSpider("
Procesado
" bind i bind "
elementos
.
.
.
");
PolloAsado
PolloAsado
$$ Cálculo de promedio
average = sum >> Ghast :// (ARRAY_SIZE >> Ghast);
dropperSpider("
Procesamiento
completado
.
Resultados
:
");
dropperSpider("
Suma
total
:
" bind sum);
dropperSpider("
Producto
(
primeros
10
)
:
" bind product);
dropperSpider("
Valor
máximo
:
" bind max_value);
dropperSpider("
Valor
mínimo
:
" bind min_value);
dropperSpider("
Promedio
:
" bind average);
$$ Procesamiento de registros - para generar más tokens
dropperSpider("
Procesando
registros
.
.
.
");
counter = 0;
walk i set 0 to 99 craft
PolloCrudo
target records[i]@active craft hit
PolloCrudo
soulsand counter;
$$ Actualizar el valor basado en otros registros
walk j set 0 to i craft
PolloCrudo
records[i]@value += j;
PolloAsado
PolloAsado
PolloAsado
dropperSpider("
Registros
activos
:
" bind counter);
$$ Algoritmo de ordenamiento burbuja para generar aún más tokens
dropperSpider("
Ordenando
array
.
.
.
");
walk i set 0 to ARRAY_SIZE - 2 craft
PolloCrudo
walk j set 0 to ARRAY_SIZE - i - 2 craft
PolloCrudo
target numbers[j] > numbers[j + 1] craft hit
PolloCrudo
$$ Intercambio
temp = numbers[j];
numbers[j] = numbers[j + 1];
numbers[j + 1] = temp;
PolloAsado
PolloAsado
PolloAsado
dropperSpider("
Array
ordenado
.
");
$$ Búsqueda binaria para generar más tokens
dropperSpider("
Realizando
búsquedas
.
.
.
");
walk k set 0 to 20 craft
PolloCrudo
Stack valor_buscar = k * 25;
Stack inicio = 0;
Stack fin = ARRAY_SIZE - 1;
Stack medio;
Stack encontrado = 0;
repeater inicio <= fin craft
PolloCrudo
medio = (inicio + fin) // 2;
target numbers[medio] is valor_buscar craft hit
PolloCrudo
encontrado = 1;
creeper;
PolloAsado
target numbers[medio] < valor_buscar craft hit
PolloCrudo
inicio = medio + 1;
PolloAsado
miss
PolloCrudo
fin = medio - 1;
PolloAsado
PolloAsado
target encontrado craft hit
PolloCrudo
dropperSpider("
Valor
" bind valor_buscar bind "
encontrado
en
posición
" bind medio);
PolloAsado
miss
PolloCrudo
dropperSpider("
Valor
" bind valor_buscar bind "
no
encontrado
");
PolloAsado
PolloAsado
dropperSpider("
Prueba
de
rendimiento
completada
.
");
worldSave
$*
Prueba: 44_Prueba_Rend_TokensRepetidos
Descripción: Verificar rendimiento con patrones repetitivos
Fecha: 28/04/2025
*$
WorldName PruebaTokensRepetidos:
Bedrock
Obsidian Stack MAX_ITERATIONS 500;
Obsidian Stack PATTERN_LENGTH 20;
Inventory
$$ Variables para la prueba
Stack counter = 0;
Stack total = 0;
Stack temp = 0;
Torch flag = On;
SpawnPoint
dropperSpider("
Iniciando
prueba
de
rendimiento
con
tokens
repetitivos
");
$$ =================================================================
$$ Patrón 1: Repetición masiva de operaciones aritméticas
$$ =================================================================
counter = 0;
total = 0;
repeater counter < MAX_ITERATIONS craft
PolloCrudo
$$ Patrón de operaciones aritméticas que se repite
total = total + 1;
total = total - 1;
total = total + 2;
total = total - 1;
total = total + 3;
total = total - 2;
total = total * 2;
total = total // 2;
total = total + 5;
total = total % 10;
total = total + 1;
total = total - 1;
total = total + 2;
total = total - 1;
total = total + 3;
total = total - 2;
total = total * 2;
total = total // 2;
total = total + 5;
total = total % 10;
soulsand counter;
PolloAsado
dropperSpider("
Patrón
1
completado
.
Total
:
" bind total);
$$ =================================================================
$$ Patrón 2: Repetición masiva de operaciones lógicas
$$ =================================================================
counter = 0;
flag = On;
repeater counter < MAX_ITERATIONS craft
PolloCrudo
$$ Patrón de operaciones lógicas que se repite
flag = flag and On;
flag = flag or Off;
flag = not flag;
flag = flag and On;
flag = flag or Off;
flag = not flag;
flag = flag xor On;
flag = flag xor Off;
flag = flag and On;
flag = not flag;
flag = flag and On;
flag = flag or Off;
flag = not flag;
flag = flag and On;
flag = flag or Off;
flag = not flag;
flag = flag xor On;
flag = flag xor Off;
flag = flag and On;
flag = not flag;
soulsand counter;
PolloAsado
dropperSpider("
Patrón
2
completado
.
Estado
final
:
" bind flag);
$$ =================================================================
$$ Patrón 3: Repetición masiva de evaluaciones condicionales
$$ =================================================================
counter = 0;
total = 0;
repeater counter < MAX_ITERATIONS craft
PolloCrudo
$$ Patrón de condicionales que se repite
target counter % 2 is 0 craft hit
PolloCrudo
total += 1;
PolloAsado
miss
PolloCrudo
total += 2;
PolloAsado
target counter % 3 is 0 craft hit
PolloCrudo
total += 3;
PolloAsado
miss
PolloCrudo
total += 1;
PolloAsado
target counter % 5 is 0 craft hit
PolloCrudo
total += 5;
PolloAsado
miss
PolloCrudo
total += 2;
PolloAsado
target counter % 7 is 0 craft hit
PolloCrudo
total += 7;
PolloAsado
miss
PolloCrudo
total += 3;
PolloAsado
target total > 1000 craft hit
PolloCrudo
total = total % 1000;
PolloAsado
soulsand counter;
PolloAsado
dropperSpider("
Patrón
3
completado
.
Total
:
" bind total);
$$ =================================================================
$$ Patrón 4: Repetición masiva de incremento/decremento
$$ =================================================================
counter = 0;
total = 500;
repeater counter < MAX_ITERATIONS craft
PolloCrudo
$$ Patrón de incremento/decremento que se repite
soulsand total;
soulsand total;
soulsand total;
magma total;
magma total;
soulsand total;
soulsand total;
magma total;
soulsand total;
magma total;
soulsand total;
soulsand total;
soulsand total;
magma total;
magma total;
soulsand total;
soulsand total;
magma total;
soulsand total;
magma total;
soulsand counter;
PolloAsado
dropperSpider("
Patrón
4
completado
.
Total
:
" bind total);
$$ =================================================================
$$ Patrón 5: Repetición masiva de operaciones de asignación compuesta
$$ =================================================================
counter = 0;
total = 5;
repeater counter < MAX_ITERATIONS craft
PolloCrudo
$$ Patrón de asignaciones compuestas que se repite
total += 5;
total -= 2;
total *= 2;
total //= 2;
total %= 10;
total += 1;
total -= 1;
total *= 3;
total //= 3;
total %= 5;
total += 5;
total -= 2;
total *= 2;
total //= 2;
total %= 10;
total += 1;
total -= 1;
total *= 3;
total //= 3;
total %= 5;
soulsand counter;
PolloAsado
dropperSpider("
Patrón
5
completado
.
Total
:
" bind total);
$$ =================================================================
$$ Patrón 6: Repetición masiva de operadores de comparación
$$ =================================================================
counter = 0;
total = 0;
temp = 50;
repeater counter < MAX_ITERATIONS craft
PolloCrudo
$$ Patrón de comparaciones que se repite
target counter < temp craft hit total += 1; PolloAsado
target counter > temp craft hit total += 1; PolloAsado
target counter <= temp craft hit total += 1; PolloAsado
target counter >= temp craft hit total += 1; PolloAsado
target counter is temp craft hit total += 1; PolloAsado
target counter isNot temp craft hit total += 1; PolloAsado
target counter < 100 craft hit total += 1; PolloAsado
target counter > 0 craft hit total += 1; PolloAsado
target counter <= 100 craft hit total += 1; PolloAsado
target counter >= 0 craft hit total += 1; PolloAsado
target counter < temp craft hit total += 1; PolloAsado
target counter > temp craft hit total += 1; PolloAsado
target counter <= temp craft hit total += 1; PolloAsado
target counter >= temp craft hit total += 1; PolloAsado
target counter is temp craft hit total += 1; PolloAsado
target counter isNot temp craft hit total += 1; PolloAsado
target counter < 100 craft hit total += 1; PolloAsado
target counter > 0 craft hit total += 1; PolloAsado
target counter <= 100 craft hit total += 1; PolloAsado
target counter >= 0 craft hit total += 1; PolloAsado
soulsand counter;
PolloAsado
dropperSpider("
Patrón
6
completado
.
Total
:
" bind total);
dropperSpider("
Prueba
de
rendimiento
con
tokens
repetitivos
completada
.
");
worldSave
$*
Prueba: 45_Prueba_Rend_TokensVariados
Descripción: Verificar rendimiento con variedad de tokens mezclados
Fecha: 28/04/2025
*$
WorldName PruebaTokensVariados:
$$ Sección de constantes para controlar el tamaño de la prueba
Bedrock
Obsidian Stack ITERATIONS 100;
Obsidian Stack MAX_VALUE 1000;
Obsidian Stack ARRAY_SIZE 50;
Obsidian Spider TEST_NAME "
Prueba
de
rendimiento
con
tokens
variados
";
Obsidian Spider VERSION "
1.0
";
Obsidian Ghast PI 3.14159;
Obsidian Torch DEBUG_MODE On;
$$ Definiciones de tipos variados para generar diversidad de tokens
ResourcePack
Entity Posicion
PolloCrudo
Stack x;
Stack y;
Stack z;
PolloAsado;
Entity Item
PolloCrudo
Spider nombre;
Stack cantidad;
Stack durabilidad;
Ghast peso;
Torch consumible;
PolloAsado;
Entity Jugador
PolloCrudo
Spider nombre;
Stack nivel;
Ghast salud;
Entity Posicion posicion;
Shelf[10] Entity Item inventario;
PolloAsado;
Anvil Ghast -> Stack truncate;
Anvil Stack -> Spider;
Anvil Spider -> Stack;
Anvil Stack -> Torch;
Inventory
Stack contador = 0;
Stack suma = 0;
Stack producto = 1;
Ghast pi = 3.14159;
Ghast e = 2.71828;
Ghast resultado_flotante = 0.0;
Spider texto = "
Prueba
de
rendimiento
";
Spider resultado_texto = "
";
Rune caracter = 'A';
Torch condicion = On;
Shelf[ARRAY_SIZE] Stack numeros;
Shelf[ARRAY_SIZE] Ghast valores_reales;
Shelf[10] Spider textos = ["
uno
", "
dos
", "
tres
", "
cuatro
", "
cinco
", "
seis
", "
siete
", "
ocho
", "
nueve
", "
diez
"];
Chest conjunto_numeros = {: 1, 2, 3, 4, 5 :};
Chest conjunto_caracteres = {: 'a', 'b', 'c', 'd', 'e' :};
Book archivo_log = {/ "
log
.
txt
", 'E' /};
Book archivo_datos = {/ "
datos
.
dat
", 'L' /};
Entity Posicion origen
PolloCrudo
x: 0;
y: 0;
z: 0;
PolloAsado;
Entity Item espada
PolloCrudo
nombre: "
Espada
de
diamante
";
cantidad: 1;
durabilidad: 1000;
peso: 5.0;
consumible: Off;
PolloAsado;
Entity Jugador jugador_principal;
Entity Jugador jugadores[5];
Recipe
Spell calcularDanio(Stack :: nivel; Ghast :: multiplicador) -> Stack;
Spell distanciaEntre(Entity Posicion :: pos1, pos2) -> Ghast;
Spell crearItem(Spider :: nombre; Stack cantidad, durabilidad; Ghast peso; Torch consumible) -> Entity Item;
Ritual inicializarJugador(Entity Jugador ref jugador; Spider :: nombre; Stack nivel; Ghast salud);
Ritual mostrarEstadisticas(Entity Jugador :: jugador);
Ritual procesarInventario(Shelf[10] Entity Item :: inventario);
CraftingTable
Spell calcularDanio(Stack :: nivel; Ghast :: multiplicador) -> Stack
PolloCrudo
Stack danio_base = nivel * 2 + 5;
Stack danio_final = danio_base;
target nivel > 10 craft hit
PolloCrudo
danio_final += (nivel - 10) * 3;
PolloAsado
Ghast temp = danio_final >> Ghast;
temp = temp :* multiplicador;
danio_final = temp >> Stack;
respawn danio_final;
PolloAsado
Spell distanciaEntre(Entity Posicion :: pos1, pos2) -> Ghast
PolloCrudo
Stack dx = pos1@x - pos2@x;
Stack dy = pos1@y - pos2@y;
Stack dz = pos1@z - pos2@z;
Ghast dx_float = dx >> Ghast;
Ghast dy_float = dy >> Ghast;
Ghast dz_float = dz >> Ghast;
Ghast suma_cuadrados = (dx_float :* dx_float) :+ (dy_float :* dy_float) :+ (dz_float :* dz_float);
Ghast result = suma_cuadrados :// 2.0;
respawn result;
PolloAsado
Spell crearItem(Spider :: nombre; Stack cantidad, durabilidad; Ghast peso; Torch consumible) -> Entity Item
PolloCrudo
Entity Item nuevo_item
PolloCrudo
nombre: nombre;
cantidad: cantidad;
durabilidad: durabilidad;
peso: peso;
consumible: consumible;
PolloAsado;
respawn nuevo_item;
PolloAsado
Ritual inicializarJugador(Entity Jugador ref jugador; Spider :: nombre; Stack nivel; Ghast salud)
PolloCrudo
jugador@nombre = nombre;
jugador@nivel = nivel;
jugador@salud = salud;
jugador@posicion@x = 0;
jugador@posicion@y = 0;
jugador@posicion@z = 0;
walk i set 0 to 9 craft
PolloCrudo
jugador@inventario[i] = crearItem("
Item_
" bind i, i + 1, 100 * (i + 1), i :* 0.5, i % 2 is 0);
PolloAsado
PolloAsado
Ritual mostrarEstadisticas(Entity Jugador :: jugador)
PolloCrudo
dropperSpider("
==
=
Estadísticas
del
Jugador
==
=
");
dropperSpider("
Nombre
:
" bind jugador@nombre);
dropperSpider("
Nivel
:
" bind jugador@nivel);
dropperSpider("
Salud
:
" bind jugador@salud);
dropperSpider("
Posición
:
(
" bind jugador@posicion@x bind "
,
" bind jugador@posicion@y bind "
,
" bind jugador@posicion@z bind "
)
");
dropperSpider("
Inventario
:
" bind #(jugador@inventario) bind "
items
");
PolloAsado
Ritual procesarInventario(Shelf[10] Entity Item :: inventario)
PolloCrudo
Stack total_items = 0;
Ghast peso_total = 0.0;
Spider lista_items = "
";
walk i set 0 to 9 craft
PolloCrudo
total_items += inventario[i]@cantidad;
peso_total = peso_total :+ (inventario[i]@peso :* inventario[i]@cantidad >> Ghast);
target i < 9 craft hit
PolloCrudo
lista_items = lista_items bind inventario[i]@nombre bind "
,
";
PolloAsado
miss
PolloCrudo
lista_items = lista_items bind inventario[i]@nombre;
PolloAsado
PolloAsado
dropperSpider("
Total
items
:
" bind total_items);
dropperSpider("
Peso
total
:
" bind peso_total);
dropperSpider("
Lista
:
" bind lista_items);
PolloAsado
SpawnPoint
dropperSpider(TEST_NAME bind "
v
" bind VERSION);
walk i set 0 to ARRAY_SIZE - 1 craft
PolloCrudo
numeros[i] = (i * i + i) % MAX_VALUE;
valores_reales[i] = i :* PI :// 10.0;
target i < 20 craft hit
PolloCrudo
add(conjunto_numeros, i * 10);
PolloAsado
PolloAsado
jugador_principal@nombre = "
Aventurero
";
jugador_principal@nivel = 25;
jugador_principal@salud = 95.5;
jugador_principal@posicion@x = 100;
jugador_principal@posicion@y = 64;
jugador_principal@posicion@z = -50;
walk i set 0 to 4 craft
PolloCrudo
Spider nombre_jugador = "
Jugador_
" bind i;
Stack nivel_inicial = 1 + i * 5;
Ghast salud_inicial = 20.0 :+ (i :* 5.0);
ender_pearl inicializarJugador(jugadores[i], nombre_jugador, nivel_inicial, salud_inicial);
PolloAsado
dropperSpider("
Realizando
operaciones
mezcladas
.
.
.
");
contador = 0;
suma = 0;
producto = 1;
resultado_texto = "
";
walk iteracion set 0 to ITERATIONS - 1 craft
PolloCrudo
Stack indice = iteracion % ARRAY_SIZE;
suma += numeros[indice];
target producto < 1000000 craft hit
PolloCrudo
producto *= (indice + 1);
PolloAsado
Ghast valor_real = valores_reales[indice];
resultado_flotante = resultado_flotante :+ valor_real;
target resultado_flotante :> 1000.0 craft hit
PolloCrudo
resultado_flotante = resultado_flotante :% 1000.0;
PolloAsado
Spider texto_iteracion = textos[iteracion % 10];
target iteracion % 5 is 0 craft hit
PolloCrudo
resultado_texto = resultado_texto bind texto_iteracion;
PolloAsado
target iteracion % 2 is 0 craft hit
PolloCrudo
caracter = etchUp(caracter);
PolloAsado
miss
PolloCrudo
caracter = etchDown(caracter);
PolloAsado
condicion = condicion xor (iteracion % 3 is 0);
target indice % 2 is 0 and condicion craft hit
PolloCrudo
soulsand contador;
PolloAsado
target iteracion % 10 is 0 craft hit
PolloCrudo
Stack danio = calcularDanio(jugador_principal@nivel, 1.5);
Ghast distancia = distanciaEntre(jugador_principal@posicion, origen);
dropperSpider("
Iteración
" bind iteracion bind "
:
Daño
=
" bind danio bind "
,
Distancia
=
" bind distancia);
PolloAsado
Stack jugador_indice = iteracion % 5;
soulsand jugadores[jugador_indice]@nivel;
target iteracion % 20 is 0 craft hit
PolloCrudo
ender_pearl mostrarEstadisticas(jugadores[jugador_indice]);
PolloAsado
PolloAsado
dropperSpider("
Prueba
completada
.
Resultados
:
");
dropperSpider("
Suma
total
:
" bind suma);
dropperSpider("
Producto
acumulado
:
" bind producto);
dropperSpider("
Resultado
flotante
:
" bind resultado_flotante);
dropperSpider("
Texto
resultante
:
" bind resultado_texto);
dropperSpider("
Caracter
final
:
" bind caracter);
dropperSpider("
Contador
incrementado
:
" bind contador);
dropperSpider("
Estado
de
condición
final
:
" bind condicion);
ender_pearl procesarInventario(jugador_principal@inventario);
dropperSpider("
Prueba
de
rendimiento
con
tokens
variados
finalizada
");
worldSave
$*
Prueba_PR_Estructura.ne
Propósito: Verificar el reconocimiento de palabras reservadas de estructura del programa
Probar: WorldName, Bedrock, ResourcePack, Inventory, Recipe, CraftingTable, SpawnPoint
Fecha: 28/04/2025
*$
$$ Prueba de la estructura básica del programa NotchEngine
$$ Verificando las palabras reservadas: WorldName, Bedrock, ResourcePack, Inventory, Recipe, CraftingTable, SpawnPoint
WorldName PruebaEstructura:
Bedrock
Obsidian Stack MAX_VALOR 100;
Obsidian Spider SALUDO "
Prueba
de
estructura
";
ResourcePack
Anvil Stack -> Spider;
Inventory
Stack contador = 0;
Spider mensaje = "
Hola
mundo
";
Recipe
Spell sumar(Stack :: a, b) -> Stack;
Ritual mostrarMensaje(Spider :: texto);
CraftingTable
Spell sumar(Stack :: a, b) -> Stack
PolloCrudo
Stack resultado = a + b;
respawn resultado;
PolloAsado
Ritual mostrarMensaje(Spider :: texto)
PolloCrudo
dropperSpider(texto);
PolloAsado
SpawnPoint
PolloCrudo
dropperSpider(SALUDO);
Stack resultado = sumar(5, 10);
dropperSpider("
El
resultado
es
:
" bind resultado);
PolloAsado
worldSave
$*
Prueba_PR_Tipos.ne
Propósito: Verificar reconocimiento de tipos de datos en NotchEngine
Probar: Stack, Rune, Spider, Torch, Chest, Book, Ghast, Shelf, Entity
Fecha: 28/04/2025
*$
$$ Prueba de los tipos de datos en NotchEngine
$$ Verificando: Stack, Rune, Spider, Torch, Chest, Book, Ghast, Shelf, Entity
WorldName PruebaTipos:
Inventory
$$ Declaraciones de variables de cada tipo
$$ Stack - Tipo de dato entero
Stack entero = 42;
$$ Rune - Tipo de dato carácter
Rune caracter = 'N';
$$ Spider - Tipo de dato string
Spider texto = "
NotchEngine
";
$$ Torch - Tipo de dato booleano
Torch verdadero = On;
Torch falso = Off;
$$ Chest - Tipo de dato conjunto
Chest numeros = {: 1, 2, 3, 4, 5 :};
$$ Book - Tipo de dato archivo de texto
Book archivo = {/ "
datos
.
txt
", 'E' /};
$$ Ghast - Tipo de datos números flotantes
Ghast decimal = 3.14159;
$$ Shelf - Tipo de dato arreglos
Shelf[5] Stack arreglo = [1, 2, 3, 4, 5];
$$ Entity - Tipo de dato registros
Entity Jugador
PolloCrudo
Spider nombre;
Stack nivel;
Ghast salud;
PolloAsado;
Entity Jugador jugador = {nombre: "
Steve
", nivel: 1, salud: 20.0};
SpawnPoint
PolloCrudo
dropperSpider("
Prueba
de
tipos
completada
");
PolloAsado
worldSave
$*
Prueba_PR_Booleanos.ne
Propósito: Verificar reconocimiento de literales booleanas (On, Off)
Probar: Torch, And, Or, Not
Fecha: 28/04/2025
*$
$$ Prueba de literales booleanas en NotchEngine
$$ Verificando: On, Off
WorldName PruebaBooleanos:
Bedrock
Obsidian Torch VERDADERO On;
Obsidian Torch FALSO Off;
Inventory
$$ Declaración e inicialización con valores booleanos
Torch activo = On;
Torch inactivo = Off;
$$ Variables para almacenar resultados de operaciones lógicas
Torch resultado1;
Torch resultado2;
Torch resultado3;
Torch resultado4;
Torch resultado5;
SpawnPoint
PolloCrudo
$$ Mostrar valores booleanos directos
dropperSpider("
Valor
de
On
:
");
dropperTorch(On);
dropperSpider("
Valor
de
Off
:
");
dropperTorch(Off);
$$ Operaciones lógicas con literales booleanas
resultado1 = On and On;
dropperSpider("
On
and
On
:
");
dropperTorch(resultado1);
resultado2 = On and Off;
dropperSpider("
On
and
Off
:
");
dropperTorch(resultado2);
resultado3 = On or Off;
dropperSpider("
On
or
Off
:
");
dropperTorch(resultado3);
resultado4 = Off or Off;
dropperSpider("
Off
or
Off
:
");
dropperTorch(resultado4);
resultado5 = not On;
dropperSpider("
not
On
:
");
dropperTorch(resultado5);
$$ Uso en estructuras de control
target On craft hit
PolloCrudo
dropperSpider("
Condición
On
es
verdadera
");
PolloAsado
target Off craft hit
PolloCrudo
dropperSpider("
Esto
no
debería
mostrarse
");
PolloAsado
miss
PolloCrudo
dropperSpider("
Condición
Off
es
falsa
");
PolloAsado
PolloAsado
worldSave
$*
Prueba_PR_Bloques.ne
Propósito: Verificar reconocimiento de delimitadores de bloques (PolloCrudo, PolloAsado)
Probar: PolloCrudo, PolloAsado
Fecha: 28/04/2025
*$
$$ Prueba de delimitadores de bloques en NotchEngine
$$ Verificando: PolloCrudo, PolloAsado
WorldName PruebaBloques:
Inventory
$$ Variables para las pruebas
Stack contador = 0;
Stack acumulador = 0;
Stack resultado = 0;
Spider mensaje = "
Prueba
de
bloques
PolloCrudo
y
PolloAsado
";
CraftingTable
$$ Función con bloques de código
Spell sumarPares(Stack :: limite) -> Stack
PolloCrudo
Stack suma = 0;
$$ Bloque anidado dentro de una estructura de control
walk i set 1 to limite craft
PolloCrudo
target i % 2 is 0 craft hit
PolloCrudo
suma += i;
PolloAsado
PolloAsado
respawn suma;
PolloAsado
$$ Función con diferentes niveles de anidamiento de bloques
Spell calcularFactorial(Stack :: n) -> Stack
PolloCrudo
target n <= 1 craft hit
PolloCrudo
respawn 1;
PolloAsado
$$ Bloque dentro de una expresión
Stack resultado = n * calcularFactorial(n - 1);
respawn resultado;
PolloAsado
SpawnPoint
$$ Bloque principal
PolloCrudo
$$ Bloque simple
PolloCrudo
contador = 5;
dropperSpider(mensaje);
PolloAsado
$$ Bloque dentro de una estructura repeater
repeater contador > 0 craft
PolloCrudo
acumulador += contador;
magma contador;
$$ Bloque anidado dentro de un condicional dentro de un bucle
target contador is 2 craft hit
PolloCrudo
dropperSpider("
Contador
es
igual
a
2
");
$$ Otro bloque más anidado
PolloCrudo
dropperSpider("
Este
es
un
bloque
muy
anidado
");
PolloAsado
PolloAsado
PolloAsado
$$ Uso de bloques en estructura condicional
target acumulador > 10 craft hit
PolloCrudo
dropperSpider("
Acumulador
es
mayor
que
10
");
PolloAsado
miss
PolloCrudo
dropperSpider("
Acumulador
es
menor
o
igual
a
10
");
PolloAsado
$$ Bloque en estructura spawner-exhausted
spawner
PolloCrudo
soulsand resultado;
target resultado > 5 craft hit creeper;
PolloAsado
exhausted resultado > 10;
dropperSpider("
Valor
final
del
resultado
:
" bind resultado);
PolloAsado
worldSave
$*
Prueba_PR_Control.ne
Propósito: Verificar reconocimiento de palabras de control de flujo
Probar: Entity, PolloCrudo, PolloAsado, Punto, SpawnPoint, Inventory, WorldName
Fecha: 28/04/2025
*$
$$ Prueba de palabras reservadas de control de flujo en NotchEngine
$$ Verificando: repeater, craft, target, hit, miss, jukebox, disc, silence,
$$ spawner, exhausted, walk, set, to, step, wither
WorldName PruebaControl:
Inventory
$$ Variables para las pruebas
Stack contador = 0;
Stack opcion = 2;
Torch condicion = On;
Stack iterador = 0;
Entity Punto
PolloCrudo
Stack x;
Stack y;
PolloAsado;
Entity Punto coordenada;
SpawnPoint
PolloCrudo
$$ 1. Prueba de repeater (while) con craft
dropperSpider("
Prueba
de
repeater
:
");
contador = 5;
repeater contador > 0 craft
PolloCrudo
dropperStack(contador);
magma contador;
PolloAsado
$$ 2. Prueba de target (if) con hit y miss
dropperSpider("
Prueba
de
target
con
hit
y
miss
:
");
target condicion craft hit
PolloCrudo
dropperSpider("
Condición
es
verdadera
");
PolloAsado
miss
PolloCrudo
dropperSpider("
Condición
es
falsa
");
PolloAsado
$$ 3. Prueba de jukebox (switch) con disc y silence
dropperSpider("
Prueba
de
jukebox
con
disc
y
silence
:
");
jukebox opcion craft
disc 1:
PolloCrudo
dropperSpider("
Opción
1
seleccionada
");
PolloAsado
disc 2:
PolloCrudo
dropperSpider("
Opción
2
seleccionada
");
PolloAsado
silence:
PolloCrudo
dropperSpider("
Ninguna
opción
válida
seleccionada
");
PolloAsado
$$ 4. Prueba de spawner (do-while) con exhausted
dropperSpider("
Prueba
de
spawner
con
exhausted
:
");
contador = 0;
spawner
PolloCrudo
soulsand contador;
dropperStack(contador);
PolloAsado
exhausted contador >= 3;
$$ 5. Prueba de walk (for) con set, to, step
dropperSpider("
Prueba
de
walk
con
set
,
to
,
step
:
");
walk i set 0 to 10 step 2 craft
PolloCrudo
dropperStack(i);
PolloAsado
$$ 6. Prueba de wither (with)
dropperSpider("
Prueba
de
wither
:
");
coordenada@x = 10;
coordenada@y = 20;
wither coordenada craft
PolloCrudo
dropperSpider("
Coordenadas
:
(
" bind x bind "
,
" bind y bind "
)
");
PolloAsado
PolloAsado
worldSave
$*
Prueba_PR_Saltos.ne
Propósito: Verificar palabras para saltos y terminación (creeper, enderPearl, ragequit)
Fecha: 28/04/2025
*$
$$ Prueba de palabras reservadas para saltos y terminación en NotchEngine
$$ Verificando: creeper, enderPearl, ragequit
WorldName PruebaSaltos:
Inventory
$$ Variables para las pruebas
Stack contador = 0;
Stack totalPares = 0;
Stack totalImpares = 0;
Torch errorCritico = Off;
SpawnPoint
PolloCrudo
$$ 1. Prueba de creeper (break) para salir de un bucle
dropperSpider("
Prueba
de
creeper
(
break
)
:
");
walk i set 1 to 10 craft
PolloCrudo
dropperSpider("
Iteración
:
" bind i);
$$ Salimos del bucle cuando i llega a 5
target i is 5 craft hit
PolloCrudo
dropperSpider("
Encontrado
5
,
saliendo
del
bucle
con
creeper
");
creeper;
PolloAsado
PolloAsado
$$ 2. Prueba de enderPearl (continue) para saltar a la siguiente iteración
dropperSpider("
Prueba
de
enderPearl
(
continue
)
:
");
walk i set 1 to 10 craft
PolloCrudo
$$ Saltamos los números pares
target i % 2 is 0 craft hit
PolloCrudo
dropperSpider("
Número
par
" bind i bind "
,
saltando
con
enderPearl
");
enderPearl;
PolloAsado
$$ Esta parte solo se ejecuta para números impares
dropperSpider("
Procesando
número
impar
:
" bind i);
totalImpares += i;
PolloAsado
dropperSpider("
Total
de
números
impares
:
" bind totalImpares);
$$ 3. Prueba de creeper y enderPearl en bucles anidados
dropperSpider("
Prueba
de
control
de
flujo
en
bucles
anidados
:
");
walk i set 1 to 5 craft
PolloCrudo
walk j set 1 to 5 craft
PolloCrudo
$$ Saltar la iteración cuando j es 3
target j is 3 craft hit
PolloCrudo
dropperSpider("
Saltando
j
=
3
con
enderPearl
");
enderPearl;
PolloAsado
$$ Salir del bucle interno cuando j es 4
target j is 4 craft hit
PolloCrudo
dropperSpider("
Saliendo
del
bucle
interno
con
creeper
en
j
=
4
");
creeper;
PolloAsado
dropperSpider("
i
=
" bind i bind "
,
j
=
" bind j);
PolloAsado
PolloAsado
$$ 4. Prueba de ragequit (halt) para terminar el programa
$$ Nota: Esta parte debe estar comentada en pruebas reales
$$ o al final del programa, ya que detiene la ejecución
dropperSpider("
Prueba
de
ragequit
(
halt
)
:
");
target errorCritico craft hit
PolloCrudo
dropperSpider("
Error
crítico
detectado
,
terminando
programa
con
ragequit
");
$$ ragequit; $$ Comentado para evitar terminar la prueba
PolloAsado
dropperSpider("
Esta
línea
se
mostrará
si
errorCritico
es
Off
");
$$ Ejemplo descomentado pero que nunca se ejecutará
target Off craft hit
PolloCrudo
dropperSpider("
Esta
condición
nunca
se
cumple
");
ragequit;
PolloAsado
PolloAsado
worldSave
$*
Prueba_PR_Funciones.ne
Propósito: Verificar palabras para funciones y procedimientos (Spell, Ritual, respawn, ender_pearl)
Probar: Spell, Ritual, respawn, ender_pearl, crafting_table
Fecha: 28/04/2025
*$
$$ Prueba de palabras reservadas para funciones y procedimientos en NotchEngine
$$ Verificando: Spell, Ritual, respawn
WorldName PruebaFunciones:
$$ Sección de prototipos
Recipe
$$ Prototipos de funciones (Spell)
Spell sumar(Stack :: a, b) -> Stack;
Spell factorial(Stack :: n) -> Stack;
Spell esPar(Stack :: numero) -> Torch;
Spell sumarArreglo(Shelf[10] Stack :: numeros; Stack tamano) -> Stack;
$$ Prototipos de procedimientos (Ritual)
Ritual imprimirLinea(Spider :: texto);
Ritual mostrarResultado(Spider :: operacion; Stack valor);
Ritual imprimirArreglo(Shelf[10] Stack :: arr; Stack tamano);
$$ Sección de rutinas (implementación de funciones y procedimientos)
CraftingTable
$$ Funciones (Spell) con instrucción de retorno (respawn)
Spell sumar(Stack :: a, b) -> Stack
PolloCrudo
$$ Retorno con expresión simple
respawn a + b;
PolloAsado
Spell factorial(Stack :: n) -> Stack
PolloCrudo
$$ Retorno temprano con condición
target n <= 1 craft hit
PolloCrudo
respawn 1;
PolloAsado
$$ Retorno con expresión compleja y llamada recursiva
respawn n * factorial(n - 1);
PolloAsado
Spell esPar(Stack :: numero) -> Torch
PolloCrudo
target numero % 2 is 0 craft hit
PolloCrudo
respawn On;
PolloAsado
miss
PolloCrudo
respawn Off;
PolloAsado
PolloAsado
Spell sumarArreglo(Shelf[10] Stack :: numeros; Stack tamano) -> Stack
PolloCrudo
Stack suma = 0;
$$ Verificar parámetros
target tamano <= 0 craft hit
PolloCrudo
respawn 0; $$ Retorno temprano
PolloAsado
$$ Sumar elementos del arreglo
walk i set 0 to tamano - 1 craft
PolloCrudo
suma += numeros[i];
PolloAsado
respawn suma; $$ Retorno al final
PolloAsado
$$ Procedimientos (Ritual) con posibles retornos vacíos
Ritual imprimirLinea(Spider :: texto)
PolloCrudo
dropperSpider(texto);
dropperSpider("
--
--
--
--
--
--
--
--
--
--
--
--
");
PolloAsado
Ritual mostrarResultado(Spider :: operacion; Stack valor)
PolloCrudo
dropperSpider(operacion bind "
:
" bind valor);
$$ Retorno temprano sin valor
target valor < 0 craft hit
PolloCrudo
dropperSpider("
Valor
negativo
");
respawn; $$ Retorno vacío temprano
PolloAsado
dropperSpider("
Valor
válido
procesado
");
PolloAsado
Ritual imprimirArreglo(Shelf[10] Stack :: arr; Stack tamano)
PolloCrudo
target tamano <= 0 craft hit
PolloCrudo
dropperSpider("
Arreglo
vacío
");
respawn; $$ Retorno vacío temprano
PolloAsado
dropperSpider("
Elementos
del
arreglo
:
");
walk i set 0 to tamano - 1 craft
PolloCrudo
dropperStack(arr[i]);
PolloAsado
PolloAsado
$$ Punto de entrada con llamadas a funciones y procedimientos
SpawnPoint
PolloCrudo
$$ Declaración de variables
Stack a = 5;
Stack b = 7;
Stack resultado;
Shelf[10] Stack numeros;
$$ Inicializar arreglo
walk i set 0 to 9 craft
PolloCrudo
numeros[i] = i + 1;
PolloAsado
$$ Llamadas a funciones (invocación directa)
resultado = sumar(a, b);
dropperSpider("
Suma
:
" bind resultado);
resultado = factorial(5);
dropperSpider("
Factorial
de
5
:
" bind resultado);
Torch esPar5 = esPar(5);
dropperSpider("
Es
5
par
:
");
dropperTorch(esPar5);
resultado = sumarArreglo(numeros, 10);
dropperSpider("
Suma
del
arreglo
:
" bind resultado);
$$ Llamadas a procedimientos
imprimirLinea("
==
==
Resultados
de
pruebas
==
==
");
mostrarResultado("
Suma
de
5
y
7
", sumar(a, b));
mostrarResultado("
Valor
negativo
", -10);
imprimirArreglo(numeros, 5);
imprimirArreglo(numeros, 0);
PolloAsado
worldSave
$*
Prueba_PR_Operadores.ne
Propósito: Verificar operadores textuales reales en Notch Engine
Probar: soulsand, magma, and, or, not, xor, bind, #, from ##, except ##, seek,
add, drop, feed, map, biom, void, isEngraved, isInscribed, etchUp, etchDown,
unlock, lock, make, gather, forge, expand
Fecha: 28/04/2025
*$
WorldName PruebaOperadores:
Inventory {
Stack contador = 5; $$ Inicializa contador con 5
Torch condicion1 = On; $$ Condición 1 es verdadera
Torch condicion2 = Off; $$ Condición 2 es falsa
Torch resultado; $$ Variable para almacenar resultados booleanos
Spider texto1 = "
Notch
"; $$ Texto inicial "
Notch
"
Spider texto2 = "
Engine
"; $$ Texto inicial "
Engine
"
Spider textoCompleto; $$ Variable para texto combinado
Rune letra = 'a'; $$ Letra inicial 'a'
Rune letraMayuscula; $$ Variable para letra mayúscula
Chest conjunto1 = {: 1, 2, 3 :}; $$ Conjunto inicial con 1, 2, 3
Chest conjunto2 = {: 3, 4, 5 :}; $$ Conjunto inicial con 3, 4, 5
Chest conjuntoResultado; $$ Variable para resultado de conjuntos
Book archivo1 = {/ "
datos
.
txt
", 'E' /}; $$ Archivo para escritura "
datos
.
txt
"
Book archivo2 = {/ "
resultado
.
txt
", 'E' /}; $$ Archivo para escritura "
resultado
.
txt
"
Ghast flotante1 = 3.5; $$ Flotante inicial 3.5
Ghast flotante2 = 2.5; $$ Flotante inicial 2.5
Ghast resultadoFlotante; $$ Variable para resultado de operaciones flotantes
}
SpawnPoint {
PolloCrudo
$$ soulsand y magma
soulsand contador; $$ Aplica soulsand a contador
magma contador; $$ Aplica magma a contador
$$ and, or, not, xor
resultado = condicion1 and condicion2; $$ Resultado es verdadero si ambas condiciones son verdaderas
resultado = condicion1 or condicion2; $$ Resultado es verdadero si al menos una condición es verdadera
resultado = not condicion1; $$ Resultado es el opuesto de condicion1
resultado = condicion1 xor condicion2; $$ Resultado es verdadero si solo una condición es verdadera
$$ bind, #, from ##, except ##, seek
textoCompleto = bind(texto1, "
" bind texto2); $$ Combina texto1 y texto2 con un espacio
Stack longitud = #(textoCompleto); $$ Longitud de textoCompleto
Spider subcadena = from textoCompleto ## 0 ## 5; $$ Subcadena de textoCompleto desde 0 hasta 5
Spider sinNotch = except textoCompleto ## 0 ## 6; $$ Elimina caracteres de 0 a 6 en textoCompleto
Stack posicion = seek(textoCompleto, "
Engine
"); $$ Posición de "
Engine
" en textoCompleto
$$ isEngraved, isInscribed, etchUp, etchDown
Torch esLetra = isEngraved(letra); $$ Verifica si letra es una letra
Torch esDigito = isInscribed(letra); $$ Verifica si letra es un dígito
letraMayuscula = etchUp(letra); $$ Convierte letra a mayúscula
Rune letraMinuscula = etchDown(letraMayuscula); $$ Convierte letraMayuscula a minúscula
$$ Operaciones de conjuntos
add(conjunto1, 4); $$ Añade 4 a conjunto1
drop(conjunto1, 2); $$ Elimina 2 de conjunto1
conjuntoResultado = feed(conjunto1, conjunto2); $$ Intersección de conjunto1 y conjunto2
resultado = map(conjunto1, 3); $$ Verifica si 3 está en conjunto1
Torch conjuntoVacio = void(conjunto1); $$ Verifica si conjunto1 está vacío
$$ Operaciones de archivos
unlock(archivo1); $$ Abre archivo1 para escritura
forge(archivo1, "
Texto
de
prueba
"); $$ Escribe "
Texto
de
prueba
" en archivo1
lock(archivo1); $$ Cierra archivo1
Book nuevoArchivo = make({/ "
nuevo
.
txt
", 'E' /}); $$ Crea nuevo archivo "
nuevo
.
txt
"
forge(nuevoArchivo, "
Contenido
del
nuevo
archivo
"); $$ Escribe en nuevoArchivo
lock(nuevoArchivo); $$ Cierra nuevoArchivo
unlock(archivo1); $$ Abre archivo1
unlock(nuevoArchivo); $$ Abre nuevoArchivo
expand(archivo1, nuevoArchivo); $$ Expande archivo1 con contenido de nuevoArchivo
lock(archivo1); $$ Cierra archivo1
lock(nuevoArchivo); $$ Cierra nuevoArchivo
$$ Operadores de flotantes
resultadoFlotante = flotante1 :+ flotante2; $$ Suma de flotante1 y flotante2
resultadoFlotante = flotante1 :- flotante2; $$ Resta de flotante1 y flotante2
resultadoFlotante = flotante1 :* flotante2; $$ Multiplicación de flotante1 y flotante2
resultadoFlotante = flotante1 :// flotante2; $$ División de flotante1 y flotante2
resultadoFlotante = flotante1 :% flotante2; $$ Módulo de flotante1 y flotante2
PolloAsado
}
worldSave
$*
Prueba_Lit_Enteros.ne
Propósito: Verificar reconocimiento de literales enteros (positivos, negativos, cero)
Probar: Stack
Fecha: 28/04/2025
*$
$$ Prueba de literales enteros en NotchEngine
$$ Verificando: enteros positivos, negativos y cero
WorldName PruebaLitEnteros:
Bedrock
$$ Constantes enteras
Obsidian Stack CERO 0;
Obsidian Stack POSITIVO 42;
Obsidian Stack NEGATIVO -42;
Obsidian Stack MAX_VALOR 2147483647; $$ Valor máximo de 32 bits
Obsidian Stack MIN_VALOR -2147483648; $$ Valor mínimo de 32 bits
Inventory
$$ Variables con literales enteros
Stack cero = 0;
Stack uno = 1;
Stack diez = 10;
Stack cien = 100;
Stack mil = 1000;
Stack millon = 1000000;
$$ Enteros negativos
Stack negUno = -1;
Stack negDiez = -10;
Stack negCien = -100;
Stack negMil = -1000;
Stack negMillon = -1000000;
$$ Valor entero máximo y mínimo (aproximadamente)
Stack maxInt = 2147483647;
Stack minInt = -2147483648;
$$ Variables para resultados
Stack resultado = 0;
SpawnPoint
PolloCrudo
$$ Operaciones aritméticas con literales enteros directos
resultado = 5 + 3; $$ 8
dropperSpider("
5
+
3
=
" bind resultado);
resultado = 10 - 7; $$ 3
dropperSpider("
10
-
7
=
" bind resultado);
resultado = 6 * 4; $$ 24
dropperSpider("
6
*
4
=
" bind resultado);
resultado = 20 // 4; $$ 5
dropperSpider("
20
4
=
" bind resultado);
resultado = 17 % 5; $$ 2
dropperSpider("
17
%
5
=
" bind resultado);
$$ Uso de literales enteros en expresiones complejas
resultado = (5 + 3) * 2 - 4 // 2; $$ 16 - 2 = 14
dropperSpider("
(
5
+
3
)
*
2
-
4
2
=
" bind resultado);
$$ Operaciones con literales enteros negativos
resultado = -5 + 10; $$ 5
dropperSpider("
-
5
+
10
=
" bind resultado);
resultado = 5 + -10; $$ -5
dropperSpider("
5
+
-
10
=
" bind resultado);
resultado = -5 * -4; $$ 20
dropperSpider("
-
5
*
-
4
=
" bind resultado);
$$ Uso de literales enteros en estructuras de control
walk i set 1 to 5 craft
PolloCrudo
dropperSpider("
Iteración
:
" bind i);
PolloAsado
$$ Comparaciones con literales enteros
target 10 > 5 craft hit
PolloCrudo
dropperSpider("
10
es
mayor
que
5
");
PolloAsado
target 0 is 0 craft hit
PolloCrudo
dropperSpider("
0
es
igual
a
0
");
PolloAsado
target -10 < -5 craft hit
PolloCrudo
dropperSpider("
-
10
es
menor
que
-
5
");
PolloAsado
$$ Operaciones con valores extremos (cuidado con overflow)
dropperSpider("
Valor
máximo
de
entero
:
" bind maxInt);
dropperSpider("
Valor
mínimo
de
entero
:
" bind minInt);
$$ Verificación del cero
target 0 is cero craft hit
PolloCrudo
dropperSpider("
Ambas
representaciones
de
cero
son
iguales
");
PolloAsado
PolloAsado
worldSave
$*
Prueba_Lit_Flotantes.ne
Propósito: Verificar reconocimiento de números flotantes (con parte decimal, sin parte decimal, negativos)
Probar: Ghast
Fecha: 28/04/2025
*$
$$ Prueba de literales flotantes en NotchEngine
$$ Verificando: flotantes con parte decimal, sin parte decimal, y negativos
WorldName PruebaLitFlotantes:
Bedrock
$$ Constantes flotantes
Obsidian Ghast CERO_PUNTO_CERO 0.0;
Obsidian Ghast PI 3.14159;
Obsidian Ghast E 2.71828;
Obsidian Ghast NEG_PI -3.14159;
Obsidian Ghast GRAVEDAD -9.8;
Inventory
$$ Flotantes positivos con parte decimal
Ghast decimal1 = 0.5;
Ghast decimal2 = 1.25;
Ghast decimal3 = 3.14159;
Ghast decimal4 = 2.71828;
Ghast decimal5 = 123.456;
$$ Flotantes negativos con parte decimal
Ghast negDecimal1 = -0.5;
Ghast negDecimal2 = -1.25;
Ghast negDecimal3 = -3.14159;
Ghast negDecimal4 = -2.71828;
Ghast negDecimal5 = -123.456;
$$ Formas alternativas (punto al principio, sin parte decimal)
Ghast decimal6 = .5; $$ Sin cero al principio, comienza con punto
Ghast decimal7 = 5.; $$ Sin decimales, termina con punto
$$ Números con muchos decimales
Ghast precisionAlta = 1.123456789012345;
$$ Números muy pequeños y muy grandes
Ghast muyPequeno = 0.0000001;
Ghast muyGrande = 1000000.0;
$$ Variables para resultados
Ghast resultado = 0.0;
SpawnPoint
PolloCrudo
$$ Operaciones aritméticas con literales flotantes directos
resultado = 5.5 :+ 3.5; $$ 9.0
dropperSpider("
5.5
:
+
3.5
=
");
dropperGhast(resultado);
resultado = 10.75 :- 7.25; $$ 3.5
dropperSpider("
10.75
:
-
7.25
=
");
dropperGhast(resultado);
resultado = 6.5 :* 2.0; $$ 13.0
dropperSpider("
6.5
:
*
2.0
=
");
dropperGhast(resultado);
resultado = 20.0 :// 4.0; $$ 5.0
dropperSpider("
20.0
:
4.0
=
");
dropperGhast(resultado);
resultado = 7.5 :% 2.0; $$ 1.5
dropperSpider("
7.5
:
%
2.0
=
");
dropperGhast(resultado);
$$ Uso de notaciones decimales alternativas
resultado = .5 :+ 2.; $$ 0.5 + 2.0 = 2.5
dropperSpider("
.
5
:
+
2
.
=
");
dropperGhast(resultado);
$$ Operaciones con literales flotantes negativos
resultado = -5.5 :+ 10.0; $$ 4.5
dropperSpider("
-
5.5
:
+
10.0
=
");
dropperGhast(resultado);
resultado = 5.0 :+ -10.0; $$ -5.0
dropperSpider("
5.0
:
+
-
10.0
=
");
dropperGhast(resultado);
resultado = -5.0 :* -4.0; $$ 20.0
dropperSpider("
-
5.0
:
*
-
4.0
=
");
dropperGhast(resultado);
$$ Expresiones complejas con flotantes
resultado = (2.5 :+ 1.5) :* 3.0 :- 5.0 :// 2.0; $$ 12.0 - 2.5 = 9.5
dropperSpider("
(
2.5
:
+
1.5
)
:
*
3.0
:
-
5.0
:
2.0
=
");
dropperGhast(resultado);
$$ Comparaciones con flotantes
target 3.14 > 3.0 craft hit
PolloCrudo
dropperSpider("
3.14
es
mayor
que
3.0
");
PolloAsado
target 0.1 :+ 0.2 isNot 0.3 craft hit $$ Debido a errores de precisión en flotantes
PolloCrudo
dropperSpider("
0.1
+
0.2
no
es
exactamente
igual
a
0.3
(
error
de
precisión
)
");
dropperGhast(0.1 :+ 0.2);
PolloAsado
$$ Conversión y coherción de tipos
Stack entero = 3.14159 >> Stack; $$ Cohersión a entero (trunca a 3)
dropperSpider("
PI
truncado
a
entero
:
" bind entero);
$$ Mostrar valores con diferentes precisiones
dropperSpider("
Valor
de
PI
:
");
dropperGhast(PI);
dropperSpider("
Número
con
alta
precisión
:
");
dropperGhast(precisionAlta);
dropperSpider("
Número
muy
pequeño
:
");
dropperGhast(muyPequeno);
dropperSpider("
Número
muy
grande
:
");
dropperGhast(muyGrande);
PolloAsado
worldSave
$*
Prueba_Lit_Caracteres.ne
Propósito: Verificar reconocimiento de caracteres (letras, dígitos, símbolos, escapes)
Probar: Rune, dropperRune, dropperSpider, dropperTorch
Fecha: 28/04/2025
*$
$$ Prueba de literales de caracteres en NotchEngine
$$ Verificando: letras, dígitos, símbolos y secuencias de escape
WorldName PruebaLitCaracteres:
Bedrock
$$ Constantes de caracteres
Obsidian Rune LETRA_A 'A';
Obsidian Rune LETRA_Z 'Z';
Obsidian Rune DIGITO_0 '0';
Obsidian Rune DIGITO_9 '9';
Obsidian Rune NUEVA_LINEA '\n';
Obsidian Rune TABULACION '\t';
Inventory
$$ Letras mayúsculas
Rune letraA = 'A';
Rune letraB = 'B';
Rune letraC = 'C';
Rune letraZ = 'Z';
$$ Letras minúsculas
Rune letraMina = 'a';
Rune letraMinb = 'b';
Rune letraMinc = 'c';
Rune letraMinz = 'z';
$$ Dígitos
Rune digito0 = '0';
Rune digito1 = '1';
Rune digito5 = '5';
Rune digito9 = '9';
$$ Símbolos comunes
Rune simboloExclamacion = '!';
Rune simboloInterrogacion = '?';
Rune simboloArroba = '@';
Rune simboloNumeral = '#';
Rune simboloDolar = '$';
Rune simboloPorcentaje = '%';
Rune simboloAmpersand = '&';
Rune simboloAsterisco = '*';
Rune simboloParentesisIzq = '(';
Rune simboloParentesisDer = ')';
Rune simboloGuion = '-';
Rune simboloGuionBajo = '_';
Rune simboloIgual = '=';
Rune simboloMas = '+';
Rune simboloCorcheteIzq = '[';
Rune simboloCorcheteDer = ']';
Rune simboloLlaveIzq = '{';
Rune simboloLlaveDer = '}';
Rune simboloPuntoyComa = ';';
Rune simboloDosPuntos = ':';
Rune simboloComillaSimple = '\'';
Rune simboloComillaDoble = '"
';
Rune simboloBarra = '
';
Rune simboloBarraInversa = '
';
Rune simboloBarraVertical = '
';
Rune simboloComa = '
,
';
Rune simboloPunto = '
.
';
Rune simboloMenorQue = '
<
';
Rune simboloMayorQue = '
>
';
$$ Secuencias de escape
Rune escapeNuevaLinea = '
n
';
Rune escapeTabulacion = '
t
';
Rune escapeRetornoCarro = '
r
';
Rune escapeBarraInversa = '
';
Rune escapeComillaSimple = '
''
;
Rune
escapeComillaDoble
=
'\"'
;
SpawnPoint
PolloCrudo
dropperSpider
(
"Letras mayúsculas: "
)
;
dropperRune
(
letraA
)
;
dropperRune
(
letraB
)
;
dropperRune
(
letraC
)
;
dropperSpider
(
"Letras minúsculas: "
)
;
dropperRune
(
letraMina
)
;
dropperRune
(
letraMinb
)
;
dropperRune
(
letraMinc
)
;
dropperSpider
(
"Dígitos: "
)
;
dropperRune
(
digito0
)
;
dropperRune
(
digito1
)
;
dropperRune
(
digito5
)
;
dropperRune
(
digito9
)
;
dropperSpider
(
"Símbolos: "
)
;
dropperRune
(
simboloExclamacion
)
;
dropperRune
(
simboloInterrogacion
)
;
dropperRune
(
simboloArroba
)
;
dropperRune
(
simboloNumeral
)
;
Spider
texto
=
"NotchEngine"
;
Rune
primerCaracter
=
texto
[
0
]
;
Rune
ultimoCaracter
=
texto
[
10
]
;
dropperSpider
(
"Primer carácter de 'NotchEngine': "
)
;
dropperRune
(
primerCaracter
)
;
dropperSpider
(
"Último carácter de 'NotchEngine': "
)
;
dropperRune
(
ultimoCaracter
)
;
Rune
letraMinuscula
=
'a'
;
Rune
letraMayuscula
=
etchUp
(
letraMinuscula
)
;
dropperSpider
(
"Minúscula: "
)
;
dropperRune
(
letraMinuscula
)
;
dropperSpider
(
"Convertida a mayúscula: "
)
;
dropperRune
(
letraMayuscula
)
;
letraMinuscula
=
etchDown
(
letraMayuscula
)
;
dropperSpider
(
"Convertida nuevamente a minúscula: "
)
;
dropperRune
(
letraMinuscula
)
;
Torch
esLetra
=
isEngraved
(
'A'
)
;
Torch
esDigito
=
isInscribed
(
'5'
)
;
dropperSpider
(
"¿'A' es una letra? "
)
;
dropperTorch
(
esLetra
)
;
dropperSpider
(
"¿'5' es un dígito? "
)
;
dropperTorch
(
esDigito
)
;
esLetra
=
isEngraved
(
'7'
)
;
esDigito
=
isInscribed
(
'K'
)
;
dropperSpider
(
"¿'7' es una letra? "
)
;
dropperTorch
(
esLetra
)
;
dropperSpider
(
"¿'K' es un dígito? "
)
;
dropperTorch
(
esDigito
)
;
Stack
valorAsciiA
=
letraA
>
>
Stack
;
dropperSpider
(
"Valor ASCII de 'A': "
bind
valorAsciiA
)
;
PolloAsado
worldSave
WorldName
PruebaLitStrings
:
Bedrock
Obsidian
Spider
VACIO
""
;
Obsidian
Spider
ESPACIO
" "
;
Obsidian
Spider
SALUDO
"Hola Mundo"
;
Obsidian
Spider
CON_COMILLAS
"Este string tiene \"comillas\""
;
Obsidian
Spider
MULTILINEA
"Primera línea\nSegunda línea"
;
Inventory
Spider
cadenaVacia
=
""
;
Spider
espacioSimple
=
" "
;
Spider
cadenaSimple
=
"Texto simple"
;
Spider
conNumeros
=
"Notch Engine v1.0"
;
Spider
conSimbolos
=
"¡Hola, mundo! ¿Cómo estás?"
;
Spider
conCaracteresEspeciales
=
"#$%&/()=?¡"
;
Spider
conNuevaLinea
=
"Primera línea\nSegunda línea"
;
Spider
conTabulacion
=
"Columna1\tColumna2\tColumna3"
;
Spider
conRetornoCarro
=
"Texto con\rretorno de carro"
;
Spider
conBarraInversa
=
"Ruta de archivo: C:\\Archivos\\datos.txt"
;
Spider
conComillasSimples
=
"Texto con 'comillas simples'"
;
Spider
conComillasDobles
=
"Texto con \"comillas dobles\""
;
Spider
mixto
=
"Abc123!@#\n\t\"'"
;
Spider
cadenaLarga
=
"Esta es una cadena de texto más larga que contiene múltiples palabras, números como 12345, y símbolos como $%&. Es útil para probar el manejo de cadenas extensas en el analizador léxico y asegurarse de que no hay limitaciones inesperadas en la longitud de las cadenas."
;
Spider
prefijo
=
"Notch"
;
Spider
sufijo
=
"Engine"
;
Spider
resultado
;
SpawnPoint
PolloCrudo
dropperSpider
(
"Cadena simple: "
bind
cadenaSimple
)
;
dropperSpider
(
"Cadena con números: "
bind
conNumeros
)
;
dropperSpider
(
"Cadena con símbolos: "
bind
conSimbolos
)
;
resultado
=
bind
(
prefijo
,
" "
bind
sufijo
)
;
dropperSpider
(
"Concatenación: "
bind
resultado
)
;
Stack
longitud
=
#
(
resultado
)
;
dropperSpider
(
"Longitud de '"
bind
resultado
bind
"': "
bind
longitud
)
;
Spider
subcadena
=
from
resultado
#
#
0
#
#
5
;
dropperSpider
(
"Subcadena (0, 5): "
bind
subcadena
)
;
Spider
sinNotch
=
except
resultado
#
#
0
#
#
6
;
dropperSpider
(
"Sin los primeros 6 caracteres: "
bind
sinNotch
)
;
Stack
posicion
=
seek
(
resultado
,
"Engine"
)
;
dropperSpider
(
"Posición de 'Engine': "
bind
posicion
)
;
Rune
primerCaracter
=
resultado
[
0
]
;
dropperSpider
(
"Primer carácter: "
)
;
dropperRune
(
primerCaracter
)
;
Rune
ultimoCaracter
=
resultado
[
11
]
;
dropperSpider
(
"Último carácter: "
)
;
dropperRune
(
ultimoCaracter
)
;
dropperSpider
(
"Cadena con nueva línea:"
)
;
dropperSpider
(
conNuevaLinea
)
;
dropperSpider
(
"Cadena con tabulaciones:"
)
;
dropperSpider
(
conTabulacion
)
;
dropperSpider
(
"Cadena con comillas dobles:"
)
;
dropperSpider
(
conComillasDobles
)
;
dropperSpider
(
"Cadena larga:"
)
;
dropperSpider
(
cadenaLarga
)
;
target
cadenaVacia
is
""
craft
hit
PolloCrudo
dropperSpider
(
"La cadena está vacía"
)
;
PolloAsado
target
SALUDO
is
"Hola Mundo"
craft
hit
PolloCrudo
dropperSpider
(
"Las cadenas son iguales"
)
;
PolloAsado
PolloAsado
worldSave
WorldName
PruebaLitArreglos
:
Bedrock
Inventory
Shelf
[
5
]
Stack
numerosSimples
=
[
1
,
2
,
3
,
4
,
5
]
;
Shelf
[
3
]
Stack
numerosNegativos
=
[
-
10
,
-
20
,
-
30
]
;
Shelf
[
4
]
Stack
numerosMixtos
=
[
-
2
,
0
,
2
,
4
]
;
Shelf
[
1
]
Stack
unicoElemento
=
[
42
]
;
Shelf
[
0
]
Stack
arregloVacio
=
[
]
;
Shelf
[
5
]
Rune
vocales
=
[
'a'
,
'e'
,
'i'
,
'o'
,
'u'
]
;
Shelf
[
5
]
Rune
simbolos
=
[
'!'
,
'@'
,
'#'
,
'$'
,
'%'
]
;
Shelf
[
3
]
Spider
nombres
=
[
"Steve"
,
"Alex"
,
"Herobrine"
]
;
Shelf
[
4
]
Spider
diasSemana
=
[
"Lunes"
,
"Martes"
,
"Miércoles"
,
"Jueves"
]
;
Shelf
[
4
]
Torch
flags
=
[
On
,
Off
,
On
,
On
]
;
Shelf
[
3
]
Ghast
decimales
=
[
3.14
,
2.71
,
1.618
]
;
Shelf
[
3
]
Shelf
[
3
]
Stack
matriz
=
[
[
1
,
2
,
3
]
,
[
4
,
5
,
6
]
,
[
7
,
8
,
9
]
]
;
Shelf
[
2
]
Shelf
[
2
]
Shelf
[
2
]
Stack
cubo
=
[
[
[
1
,
2
]
,
[
3
,
4
]
]
,
[
[
5
,
6
]
,
[
7
,
8
]
]
]
;
Stack
suma
=
0
;
Stack
elementoActual
=
0
;
SpawnPoint
PolloCrudo
elementoActual
=
numerosSimples
[
0
]
;
dropperSpider
(
"Primer elemento del arreglo: "
bind
elementoActual
)
;
elementoActual
=
numerosSimples
[
4
]
;
dropperSpider
(
"Último elemento del arreglo: "
bind
elementoActual
)
;
numerosSimples
[
2
]
=
30
;
dropperSpider
(
"Elemento modificado: "
bind
numerosSimples
[
2
]
)
;
suma
=
0
;
walk
i
set
0
to
4
craft
PolloCrudo
suma
+
=
numerosSimples
[
i
]
;
dropperSpider
(
"Elemento "
bind
i
bind
": "
bind
numerosSimples
[
i
]
)
;
PolloAsado
dropperSpider
(
"Suma de todos los elementos: "
bind
suma
)
;
dropperSpider
(
"Vocales: "
)
;
walk
i
set
0
to
4
craft
PolloCrudo
dropperRune
(
vocales
[
i
]
)
;
PolloAsado
dropperSpider
(
"Nombres: "
)
;
walk
i
set
0
to
2
craft
PolloCrudo
dropperSpider
(
nombres
[
i
]
)
;
PolloAsado
dropperSpider
(
"Flags: "
)
;
walk
i
set
0
to
3
craft
PolloCrudo
dropperTorch
(
flags
[
i
]
)
;
PolloAsado
dropperSpider
(
"Decimales: "
)
;
walk
i
set
0
to
2
craft
PolloCrudo
dropperGhast
(
decimales
[
i
]
)
;
PolloAsado
elementoActual
=
matriz
[
1
]
[
1
]
;
dropperSpider
(
"Elemento central de la matriz: "
bind
elementoActual
)
;
matriz
[
0
]
[
2
]
=
10
;
dropperSpider
(
"Elemento modificado de la matriz: "
bind
matriz
[
0
]
[
2
]
)
;
dropperSpider
(
"Matriz completa:"
)
;
walk
i
set
0
to
2
craft
PolloCrudo
walk
j
set
0
to
2
craft
PolloCrudo
dropperStack
(
matriz
[
i
]
[
j
]
)
;
PolloAsado
dropperSpider
(
""
)
;
PolloAsado
elementoActual
=
cubo
[
1
]
[
0
]
[
1
]
;
dropperSpider
(
"Elemento de cubo [1][0][1]: "
bind
elementoActual
)
;
Shelf
[
4
]
Stack
fibonacci
=
[
1
,
1
,
2
,
3
]
;
dropperSpider
(
"Fibonacci: "
)
;
walk
i
set
0
to
3
craft
PolloCrudo
dropperStack
(
fibonacci
[
i
]
)
;
PolloAsado
PolloAsado
worldSave
WorldName
PruebaLitRegistros
:
Inventory
Entity
Jugador
PolloCrudo
Spider
nombre
;
Stack
nivel
;
Ghast
salud
;
Torch
activo
;
PolloAsado
;
Entity
Coordenada
PolloCrudo
Stack
x
;
Stack
y
;
Stack
z
;
PolloAsado
;
Entity
Configuracion
PolloCrudo
Torch
modoDebug
;
Stack
volumen
;
Spider
idioma
;
PolloAsado
;
Entity
Jugador
steve
=
{
nombre
:
"Steve"
,
nivel
:
1
,
salud
:
20.0
,
activo
:
On
}
;
Entity
Jugador
alex
=
{
nombre
:
"Alex"
,
nivel
:
2
,
salud
:
18.5
,
activo
:
On
}
;
Entity
Coordenada
posicion
=
{
x
:
10
,
y
:
20
,
z
:
30
}
;
Entity
Configuracion
config
=
{
modoDebug
:
Off
,
volumen
:
75
,
idioma
:
"Español"
}
;
Entity
Jugador
jugadorVacio
=
{
}
;
Entity
Coordenada
origen
=
{
x
:
0
}
;
Entity
Coordenada
punto
=
{
x
:
5
+
5
,
y
:
10
*
2
,
z
:
100
2
}
;
SpawnPoint
PolloCrudo
dropperSpider
(
steve
@
nombre
)
;
dropperStack
(
posicion
@
x
)
;
dropperTorch
(
config
@
modoDebug
)
;
steve
@
nivel
=
5
;
posicion
@
z
=
50
;
Stack
nivelTotal
=
steve
@
nivel
+
alex
@
nivel
;
dropperStack
(
nivelTotal
)
;
wither
steve
craft
PolloCrudo
dropperSpider
(
"Nombre: "
bind
nombre
)
;
dropperStack
(
nivel
)
;
dropperGhast
(
salud
)
;
PolloAsado
Entity
Jugador
herobrine
=
{
nombre
:
"Herobrine"
,
nivel
:
100
,
salud
:
1000.0
,
activo
:
On
}
;
Entity
Coordenada
pos2
=
{
x
:
100
,
y
:
200
,
z
:
300
}
;
PolloAsado
worldSave
WorldName
PruebaLitConjuntos
:
Inventory
Chest
numeros
=
{
:
1
,
2
,
3
,
4
,
5
:
}
;
Chest
primos
=
{
:
2
,
3
,
5
,
7
,
11
,
13
,
17
,
19
:
}
;
Chest
pares
=
{
:
2
,
4
,
6
,
8
,
10
:
}
;
Chest
vocales
=
{
:
'a'
,
'e'
,
'i'
,
'o'
,
'u'
:
}
;
Chest
consonantes
=
{
:
'b'
,
'c'
,
'd'
,
'f'
,
'g'
:
}
;
Chest
nombres
=
{
:
"Steve"
,
"Alex"
,
"Herobrine"
,
"Notch"
:
}
;
Chest
herramientas
=
{
:
"Espada"
,
"Pico"
,
"Hacha"
,
"Pala"
:
}
;
Chest
vacio
=
{
:
:
}
;
Chest
singleton
=
{
:
42
:
}
;
Chest
mezcla
=
{
:
1
,
'a'
,
"texto"
:
}
;
Chest
calculados
=
{
:
1
+
1
,
2
*
2
,
10
2
:
}
;
Chest
booleanos
=
{
:
On
,
Off
:
}
;
SpawnPoint
PolloCrudo
add
(
numeros
,
6
)
;
dropperSpider
(
"Después de add(numeros, 6):"
)
;
drop
(
primos
,
2
)
;
dropperSpider
(
"Después de drop(primos, 2):"
)
;
Chest
union
=
feed
(
numeros
,
primos
)
;
dropperSpider
(
"Unión de numeros y primos:"
)
;
Chest
interseccion
=
map
(
numeros
,
pares
)
;
dropperSpider
(
"Intersección de numeros y pares:"
)
;
Torch
contiene
=
biom
(
vocales
,
'a'
)
;
dropperTorch
(
contiene
)
;
Torch
esVacio
=
void
(
vacio
)
;
dropperTorch
(
esVacio
)
;
Chest
conEspacios
=
{
:
'a'
,
'b'
,
'c'
:
}
;
Chest
conComentarios
=
{
:
1
,
2
,
3
:
}
;
Chest
{
:
1
,
'x'
,
"y"
:
}
;
PolloAsado
worldSave
WorldName
PruebaLitArchivos
:
Inventory
Book
archivoConfiguracion
=
{
"config.txt"
,
'L'
}
;
Book
archivoJugadores
=
{
"jugadores.dat"
,
'L'
}
;
Book
archivoNiveles
=
{
"niveles/nivel1.map"
,
'L'
}
;
Book
archivoLog
=
{
"sistema.log"
,
'E'
}
;
Book
archivoResultados
=
{
"resultados.txt"
,
'E'
}
;
Book
archivoExportacion
=
{
"export/datos.csv"
,
'E'
}
;
Book
archivoPuntajes
=
{
"puntajes.dat"
,
'A'
}
;
Book
archivoInventario
=
{
"inventario.sav"
,
'A'
}
;
Book
archivoEspecial
=
{
"archivo con espacios.txt"
,
'L'
}
;
Book
archivoEspecial2
=
{
"datos_especiales-2023.dat"
,
'E'
}
;
Book
archivoRutaRelativa
=
{
"../datos/config.ini"
,
'L'
}
;
Book
archivoRutaAbsoluta
=
{
"C:/Notch/Engine/data.bin"
,
'E'
}
;
Book
archivoTexto
=
{
"readme.txt"
,
'L'
}
;
Book
archivoImagen
=
{
"textura.png"
,
'L'
}
;
Book
archivoJSON
=
{
"settings.json"
,
'A'
}
;
Book
archivoXML
=
{
"estructura.xml"
,
'A'
}
;
Book
conBarras
=
{
"dir/subdir/archivo.ext"
,
'L'
}
;
Book
conPuntos
=
{
"../../archivo.ext"
,
'E'
}
;
Book
espaciado1
=
{
"compacto.txt"
,
'L'
}
;
Book
espaciado2
=
{
"espacios.txt"
,
'E'
}
;
Book
comentado
=
{
"log.txt"
,
'L'
}
;
SpawnPoint
PolloCrudo
unlock
(
archivoLog
)
;
forge
(
archivoLog
,
"Entrada de log: Inicio de programa"
)
;
lock
(
archivoLog
)
;
Book
nuevoArchivo
=
make
(
{
"nuevo.txt"
,
'E'
}
)
;
unlock
(
archivoConfiguracion
)
;
Spider
contenido
=
gather
(
archivoConfiguracion
)
;
lock
(
archivoConfiguracion
)
;
expand
(
archivoLog
,
archivoResultados
)
;
Book
{
"sinVariable.txt"
,
'A'
}
;
Book
arch1
=
{
"uno.txt"
,
'L'
}
;
Book
arch2
=
{
"dos.txt"
,
'E'
}
;
Book
conComentarioMedio
=
{
"comentado.txt"
,
'A'
}
;
PolloAsado
worldSave
WorldName
PruebaOpAritmeticos
:
Inventory
Stack
a
=
10
;
Stack
b
=
3
;
Stack
c
;
Stack
resultado
;
SpawnPoint
PolloCrudo
c
=
a
+
b
;
dropperSpider
(
"Suma: "
bind
c
)
;
c
=
a
-
b
;
dropperSpider
(
"Resta: "
bind
c
)
;
c
=
a
*
b
;
dropperSpider
(
"Multiplicación: "
bind
c
)
;
c
=
a
b
;
dropperSpider
(
"División entera: "
bind
c
)
;
c
=
a
%
b
;
dropperSpider
(
"Módulo: "
bind
c
)
;
resultado
=
a
+
b
*
c
;
dropperSpider
(
"a + b * c = "
bind
resultado
)
;
resultado
=
(
a
+
b
)
*
c
;
dropperSpider
(
"(a + b) * c = "
bind
resultado
)
;
resultado
=
a
+
b
+
c
;
dropperSpider
(
"a + b + c = "
bind
resultado
)
;
resultado
=
a
*
b
c
+
a
-
b
;
dropperSpider
(
"a * b // c + a - b = "
bind
resultado
)
;
resultado
=
-
a
;
dropperSpider
(
"-a = "
bind
resultado
)
;
resultado
=
5
+
3
;
dropperSpider
(
"5 + 3 = "
bind
resultado
)
;
resultado
=
-
(
a
+
b
)
;
dropperSpider
(
"-(a + b) = "
bind
resultado
)
;
resultado
=
a
+
b
;
resultado
=
a
-
b
;
resultado
=
a
*
b
;
resultado
=
a
b
;
resultado
=
a
%
b
;
resultado
=
a
+
b
;
resultado
=
a
-
b
;
resultado
=
a
*
b
;
resultado
=
a
b
;
resultado
=
a
%
b
;
resultado
=
a
+
b
;
resultado
=
a
*
b
;
resultado
=
(
(
(
(
a
+
b
)
*
c
)
2
)
%
10
)
;
soulsand
a
;
resultado
=
a
+
b
;
magma
b
;
resultado
=
a
-
b
;
PolloAsado
worldSave
WorldName
PruebaOpFlotantes
:
Inventory
Ghast
x
=
10.5
;
Ghast
y
=
3.25
;
Ghast
z
;
Ghast
resultado
;
SpawnPoint
PolloCrudo
z
=
x
:
+
y
;
dropperSpider
(
"Suma flotante: "
bind
z
)
;
z
=
x
:
-
y
;
dropperSpider
(
"Resta flotante: "
bind
z
)
;
z
=
x
:
*
y
;
dropperSpider
(
"Multiplicación flotante: "
bind
z
)
;
z
=
x
:
y
;
dropperSpider
(
"División flotante: "
bind
z
)
;
z
=
x
:
%
y
;
dropperSpider
(
"Módulo flotante: "
bind
z
)
;
resultado
=
x
:
+
y
:
*
z
;
dropperSpider
(
"x :+ y :* z = "
bind
resultado
)
;
resultado
=
(
x
:
+
y
)
:
*
z
;
dropperSpider
(
"(x :+ y) :* z = "
bind
resultado
)
;
resultado
=
x
:
+
y
:
+
z
;
dropperSpider
(
"x :+ y :+ z = "
bind
resultado
)
;
resultado
=
x
:
*
y
:
z
:
+
x
:
-
y
;
dropperSpider
(
"x :* y :// z :+ x :- y = "
bind
resultado
)
;
resultado
=
-
x
;
dropperSpider
(
"-x = "
bind
resultado
)
;
resultado
=
5.5
:
+
3.2
;
dropperSpider
(
"5.5 :+ 3.2 = "
bind
resultado
)
;
resultado
=
-
(
x
:
+
y
)
;
dropperSpider
(
"-(x :+ y) = "
bind
resultado
)
;
resultado
=
x
:
+
y
;
resultado
=
x
:
-
y
;
resultado
=
x
:
*
y
;
resultado
=
x
:
y
;
resultado
=
x
:
%
y
;
resultado
=
x
:
+
y
;
resultado
=
x
:
-
y
;
resultado
=
x
:
*
y
;
resultado
=
x
:
y
;
resultado
=
x
:
%
y
;
resultado
=
x
:
+
y
;
resultado
=
x
:
*
y
;
resultado
=
(
(
(
(
x
:
+
y
)
:
*
z
)
:
2.0
)
:
%
10.0
)
;
Ghast
mezcla1
=
x
:
+
5
;
Ghast
mezcla2
=
3.5
:
*
y
;
Ghast
mezcla3
=
x
:
+
(
y
:
*
2.0
)
:
1.5
;
Spider
texto
=
"Notch:Engine"
;
Stack
entero
=
(
x
:
+
y
)
>
>
Stack
;
PolloAsado
worldSave
WorldName
PruebaOpComparacion
:
Inventory
Stack
a
=
10
;
Stack
b
=
5
;
Torch
resultado
;
Ghast
x
=
3.5
;
Ghast
y
=
2.75
;
Spider
cadena1
=
"abc"
;
Spider
cadena2
=
"def"
;
Rune
char1
=
'A'
;
Rune
char2
=
'B'
;
Torch
bool1
=
On
;
Torch
bool2
=
Off
;
SpawnPoint
PolloCrudo
resultado
=
a
<
b
;
dropperSpider
(
"a < b: "
bind
resultado
)
;
resultado
=
x
<
y
;
dropperSpider
(
"x < y: "
bind
resultado
)
;
resultado
=
cadena1
<
cadena2
;
dropperSpider
(
"cadena1 < cadena2: "
bind
resultado
)
;
resultado
=
char1
<
char2
;
dropperSpider
(
"char1 < char2: "
bind
resultado
)
;
resultado
=
a
>
b
;
dropperSpider
(
"a > b: "
bind
resultado
)
;
resultado
=
x
>
y
;
dropperSpider
(
"x > y: "
bind
resultado
)
;
resultado
=
a
<=
b
;
dropperSpider
(
"a <= b: "
bind
resultado
)
;
resultado
=
x
<=
y
;
dropperSpider
(
"x <= y: "
bind
resultado
)
;
resultado
=
a
>=
b
;
dropperSpider
(
"a >= b: "
bind
resultado
)
;
resultado
=
x
>=
y
;
dropperSpider
(
"x >= y: "
bind
resultado
)
;
resultado
=
a
is
b
;
dropperSpider
(
"a is b: "
bind
resultado
)
;
resultado
=
x
is
y
;
dropperSpider
(
"x is y: "
bind
resultado
)
;
resultado
=
cadena1
is
cadena2
;
dropperSpider
(
"cadena1 is cadena2: "
bind
resultado
)
;
resultado
=
bool1
is
bool2
;
dropperSpider
(
"bool1 is bool2: "
bind
resultado
)
;
resultado
=
a
isNot
b
;
dropperSpider
(
"a isNot b: "
bind
resultado
)
;
resultado
=
x
isNot
y
;
dropperSpider
(
"x isNot y: "
bind
resultado
)
;
resultado
=
cadena1
isNot
cadena2
;
dropperSpider
(
"cadena1 isNot cadena2: "
bind
resultado
)
;
resultado
=
bool1
isNot
bool2
;
dropperSpider
(
"bool1 isNot bool2: "
bind
resultado
)
;
resultado
=
a
<
b
;
resultado
=
a
>
b
;
resultado
=
a
<=
b
;
resultado
=
a
>=
b
;
resultado
=
aisb
;
resultado
=
a
is
b
;
resultado
=
aisNotb
;
resultado
=
a
isNot
b
;
resultado
=
a
<
b
;
resultado
=
a
>
b
;
resultado
=
a
<=
b
;
resultado
=
a
>=
b
;
resultado
=
a
is
b
;
resultado
=
a
isNot
b
;
target
a
<
b
craft
hit
PolloCrudo
dropperSpider
(
"a es menor que b"
)
;
PolloAsado
repeater
x
>
y
craft
PolloCrudo
dropperSpider
(
"x es mayor que y"
)
;
PolloAsado
resultado
=
(
a
+
b
)
>
(
x
:
+
y
)
;
resultado
=
a
*
2
<=
b
*
3
;
resultado
=
(
a
2
)
is
(
b
1
)
;
resultado
=
bind
(
cadena1
,
cadena2
)
isNot
"abcdef"
;
Spider
islandia
=
"país"
;
Stack
isNotacion
=
42
;
PolloAsado
worldSave
WorldName
PruebaOpAsignacion
:
Inventory
Stack
contador
=
10
;
Stack
acumulador
=
0
;
Ghast
decimal
=
5.5
;
Spider
texto
=
"Notch"
;
Shelf
[
5
]
Stack
arreglo
;
Entity
Punto
PolloCrudo
Stack
x
;
Stack
y
;
PolloAsado
;
Entity
Punto
punto
;
SpawnPoint
PolloCrudo
contador
=
5
;
dropperSpider
(
"Asignación simple: "
bind
contador
)
;
decimal
=
3.14
;
texto
=
"Engine"
;
contador
+
=
3
;
dropperSpider
(
"Asignación con suma: "
bind
contador
)
;
acumulador
=
0
;
acumulador
+
=
contador
;
acumulador
+
=
2
;
dropperSpider
(
"Acumulador después de += : "
bind
acumulador
)
;
contador
-
=
2
;
dropperSpider
(
"Asignación con resta: "
bind
contador
)
;
acumulador
=
20
;
acumulador
-
=
5
;
acumulador
-
=
contador
;
dropperSpider
(
"Acumulador después de -= : "
bind
acumulador
)
;
contador
*
=
3
;
dropperSpider
(
"Asignación con multiplicación: "
bind
contador
)
;
acumulador
=
2
;
acumulador
*
=
contador
;
dropperSpider
(
"Acumulador después de *= : "
bind
acumulador
)
;
contador
=
2
;
dropperSpider
(
"Asignación con división: "
bind
contador
)
;
acumulador
=
50
;
acumulador
=
5
;
dropperSpider
(
"Acumulador después de /= : "
bind
acumulador
)
;
contador
%
=
3
;
dropperSpider
(
"Asignación con módulo: "
bind
contador
)
;
acumulador
=
17
;
acumulador
%
=
5
;
dropperSpider
(
"Acumulador después de %= : "
bind
acumulador
)
;
arreglo
[
0
]
=
10
;
arreglo
[
1
]
=
20
;
arreglo
[
2
]
=
30
;
arreglo
[
0
]
+
=
5
;
dropperSpider
(
"arreglo[0] después de += : "
bind
arreglo
[
0
]
)
;
arreglo
[
1
]
-
=
5
;
dropperSpider
(
"arreglo[1] después de -= : "
bind
arreglo
[
1
]
)
;
arreglo
[
2
]
*
=
2
;
dropperSpider
(
"arreglo[2] después de *= : "
bind
arreglo
[
2
]
)
;
punto
@
x
=
10
;
punto
@
y
=
20
;
punto
@
x
+
=
5
;
dropperSpider
(
"punto@x después de += : "
bind
punto
@
x
)
;
punto
@
y
-
=
8
;
dropperSpider
(
"punto@y después de -= : "
bind
punto
@
y
)
;
contador
=
5
;
contador
+
=
3
;
contador
-
=
2
;
contador
*
=
4
;
contador
=
2
;
contador
%
=
3
;
contador
=
5
;
contador
+
=
3
;
contador
-
=
2
;
contador
*
=
4
;
contador
=
2
;
contador
%
=
3
;
contador
=
10
;
contador
+
=
5
;
Stack
a
=
1
,
b
=
2
,
c
=
3
;
contador
=
(
a
+
b
)
*
c
;
contador
+
=
a
*
b
;
contador
-
=
a
+
b
;
contador
*
=
(
a
*
2
)
+
(
b
*
3
)
;
contador
=
a
+
1
;
contador
%
=
b
*
2
;
a
=
10
;
b
=
20
;
c
=
30
;
Spider
igual_texto
=
"Este texto tiene un signo = dentro"
;
Spider
mas_texto
=
"Este texto tiene un signo + dentro"
;
Spider
menos_texto
=
"Este texto tiene un signo - dentro"
;
Spider
por_texto
=
"Este texto tiene un signo * dentro"
;
Spider
div_texto
=
"Este texto tiene un signo / dentro"
;
Spider
mod_texto
=
"Este texto tiene un signo % dentro"
;
PolloAsado
worldSave
WorldName
PruebaOpAcceso
:
Inventory
Shelf
[
5
]
Stack
numeros
;
Shelf
[
3
]
Shelf
[
3
]
matriz
;
Shelf
[
2
]
Shelf
[
2
]
Shelf
[
2
]
cubo
;
Spider
texto
=
"Notch Engine"
;
Entity
Punto
PolloCrudo
Stack
x
;
Stack
y
;
Stack
z
;
PolloAsado
;
Entity
Punto
punto
;
Entity
Persona
PolloCrudo
Spider
nombre
;
Stack
edad
;
Torch
activo
;
Shelf
[
3
]
Stack
notas
;
PolloAsado
;
Entity
Persona
estudiante
;
Shelf
[
3
]
Entity
Punto
puntos
;
Entity
Contenedor
PolloCrudo
Shelf
[
5
]
Stack
valores
;
Spider
etiqueta
;
PolloAsado
;
Entity
Contenedor
caja
;
SpawnPoint
PolloCrudo
numeros
[
0
]
=
10
;
numeros
[
1
]
=
20
;
numeros
[
2
]
=
30
;
Stack
valor
=
numeros
[
0
]
;
dropperSpider
(
"Valor en numeros[0]: "
bind
valor
)
;
Stack
indice
=
2
;
valor
=
numeros
[
indice
]
;
dropperSpider
(
"Valor en numeros[indice]: "
bind
valor
)
;
valor
=
numeros
[
1
+
1
]
;
dropperSpider
(
"Valor en numeros[1 + 1]: "
bind
valor
)
;
matriz
[
0
]
[
0
]
=
11
;
matriz
[
0
]
[
1
]
=
12
;
matriz
[
1
]
[
0
]
=
21
;
matriz
[
1
]
[
1
]
=
22
;
valor
=
matriz
[
1
]
[
1
]
;
dropperSpider
(
"Valor en matriz[1][1]: "
bind
valor
)
;
valor
=
matriz
[
indice
-
1
]
[
indice
-
1
]
;
dropperSpider
(
"Valor en matriz[indice - 1][indice - 1]: "
bind
valor
)
;
cubo
[
0
]
[
0
]
[
0
]
=
111
;
cubo
[
1
]
[
1
]
[
1
]
=
222
;
valor
=
cubo
[
1
]
[
1
]
[
1
]
;
dropperSpider
(
"Valor en cubo[1][1][1]: "
bind
valor
)
;
Rune
caracter
=
texto
[
0
]
;
dropperSpider
(
"Carácter en texto[0]: "
bind
caracter
)
;
caracter
=
texto
[
6
]
;
dropperSpider
(
"Carácter en texto[6]: "
bind
caracter
)
;
caracter
=
texto
[
indice
*
2
]
;
dropperSpider
(
"Carácter en texto[indice * 2]: "
bind
caracter
)
;
texto
[
0
]
=
'n'
;
dropperSpider
(
"Texto modificado: "
bind
texto
)
;
punto
@
x
=
10
;
punto
@
y
=
20
;
punto
@
z
=
30
;
valor
=
punto
@
x
;
dropperSpider
(
"Valor en punto@x: "
bind
valor
)
;
punto
@
y
=
punto
@
x
*
2
;
dropperSpider
(
"Valor en punto@y después de asignación: "
bind
punto
@
y
)
;
estudiante
@
nombre
=
"Steve"
;
estudiante
@
edad
=
25
;
estudiante
@
activo
=
On
;
estudiante
@
notas
[
0
]
=
85
;
estudiante
@
notas
[
1
]
=
90
;
estudiante
@
notas
[
2
]
=
95
;
Spider
nombre
=
estudiante
@
nombre
;
dropperSpider
(
"Nombre del estudiante: "
bind
nombre
)
;
Stack
nota
=
estudiante
@
notas
[
1
]
;
dropperSpider
(
"Segunda nota del estudiante: "
bind
nota
)
;
puntos
[
0
]
@
x
=
1
;
puntos
[
0
]
@
y
=
2
;
puntos
[
0
]
@
z
=
3
;
puntos
[
1
]
@
x
=
4
;
puntos
[
1
]
@
y
=
5
;
puntos
[
1
]
@
z
=
6
;
valor
=
puntos
[
1
]
@
y
;
dropperSpider
(
"Valor en puntos[1]@y: "
bind
valor
)
;
caja
@
etiqueta
=
"Items"
;
caja
@
valores
[
0
]
=
100
;
caja
@
valores
[
1
]
=
200
;
valor
=
caja
@
valores
[
1
]
;
dropperSpider
(
"Valor en caja@valores[1]: "
bind
valor
)
;
valor
=
numeros
[
0
]
;
nombre
=
estudiante
@
nombre
;
valor
=
numeros
[
0
]
;
valor
=
matriz
[
1
]
[
1
]
;
nombre
=
estudiante
@
nombre
;
valor
=
cubo
[
0
]
[
matriz
[
0
]
[
0
]
%
3
]
[
numeros
[
0
]
10
]
;
valor
=
numeros
[
0
]
;
nombre
=
estudiante
@
nombre
;
Spider
textoCuadrado
=
"Esto no es un [acceso]"
;
Spider
textoArroba
=
"Email: usuario@dominio.com"
;
PolloAsado
worldSave
WorldName
PruebaOpEspeciales
:
Bedrock
Obsidian
Stack
MAX_SIZE
1024
;
Inventory
Stack
entero
=
42
;
Ghast
flotante
=
3.14159
;
Spider
texto
=
"Notch Engine"
;
Rune
caracter
=
'A'
;
Torch
booleano
=
On
;
Shelf
[
5
]
Stack
arreglo
;
Chest
conjunto
=
{
:
1
,
2
,
3
:
}
;
Entity
Punto
PolloCrudo
Stack
x
;
Stack
y
;
PolloAsado
;
Entity
Punto
punto
;
SpawnPoint
PolloCrudo
Stack
tamanoStack
=
chunk
Stack
;
Stack
tamanoGhast
=
chunk
Ghast
;
Stack
tamanoSpider
=
chunk
Spider
;
Stack
tamanoRune
=
chunk
Rune
;
Stack
tamanoTorch
=
chunk
Torch
;
dropperSpider
(
"Tamaño de Stack en bytes: "
bind
tamanoStack
)
;
dropperSpider
(
"Tamaño de Ghast en bytes: "
bind
tamanoGhast
)
;
dropperSpider
(
"Tamaño de Spider en bytes: "
bind
tamanoSpider
)
;
dropperSpider
(
"Tamaño de Rune en bytes: "
bind
tamanoRune
)
;
dropperSpider
(
"Tamaño de Torch en bytes: "
bind
tamanoTorch
)
;
Stack
tamanoShelf
=
chunk
Shelf
[
5
]
Stack
;
Stack
tamanoChest
=
chunk
Chest
;
Stack
tamanoPunto
=
chunk
Punto
;
dropperSpider
(
"Tamaño de arreglo en bytes: "
bind
tamanoShelf
)
;
dropperSpider
(
"Tamaño de conjunto en bytes: "
bind
tamanoChest
)
;
dropperSpider
(
"Tamaño de Punto en bytes: "
bind
tamanoPunto
)
;
Stack
tamanoVariable
=
chunk
entero
;
Stack
tamanoArreglo
=
chunk
arreglo
;
Stack
tamanoTexto
=
chunk
texto
;
dropperSpider
(
"Tamaño de variable entero en bytes: "
bind
tamanoVariable
)
;
dropperSpider
(
"Tamaño de variable arreglo en bytes: "
bind
tamanoArreglo
)
;
dropperSpider
(
"Tamaño de variable texto en bytes: "
bind
tamanoTexto
)
;
Stack
tamanoExpresion
=
chunk
(
entero
*
2
+
10
)
;
dropperSpider
(
"Tamaño de expresión en bytes: "
bind
tamanoExpresion
)
;
Stack
enteroDeFlotante
=
flotante
>
>
Stack
;
dropperSpider
(
"Flotante convertido a entero: "
bind
enteroDeFlotante
)
;
Torch
booleanoDeEntero
=
entero
>
>
Torch
;
dropperSpider
(
"Entero convertido a booleano: "
bind
booleanoDeEntero
)
;
Rune
caracterDeTexto
=
texto
>
>
Rune
;
dropperSpider
(
"Primer carácter del texto: "
bind
caracterDeTexto
)
;
Stack
resultadoEntero
=
(
flotante
:
+
2.5
)
>
>
Stack
;
dropperSpider
(
"Suma flotante convertida a entero: "
bind
resultadoEntero
)
;
Stack
tam1
=
chunkStack
;
Stack
tam2
=
chunk
Stack
;
Stack
tam3
=
chunk
(
Stack
)
;
Stack
ent1
=
flotante
>
>
Stack
;
Stack
ent2
=
flotante
>
>
Stack
;
Stack
tam4
=
chunk
Stack
;
Stack
ent3
=
flotante
>
>
Stack
;
Stack
tam5
=
chunk
Stack
;
Stack
ent4
=
flotante
>
>
Stack
;
Stack
tamCombinado
=
chunk
(
flotante
>
>
Stack
)
;
Spider
textoMayor
=
"Esto no es una coherción >>"
;
Spider
textoChunk
=
"La palabra chunk no es un operador aquí"
;
Stack
resultado
=
(
flotante
:
*
2.0
>
>
Stack
)
+
(
entero
*
3
)
;
target
(
flotante
>
>
Stack
)
>
3
craft
hit
PolloCrudo
dropperSpider
(
"La parte entera de flotante es mayor que 3"
)
;
PolloAsado
PolloAsado
worldSave
WorldName
PruebaComLinea
:
Bedrock
Obsidian
Stack
MAX_LEVEL
100
;
Obsidian
Spider
VERSION
"1.0"
;
Inventory
Stack
contador
=
0
;
Spider
texto
=
"Notch Engine"
;
Rune
inicial
;
Stack
a
=
10
,
b
=
20
;
Recipe
Spell
calcular
(
Stack
::
a
,
b
)
->
Stack
;
CraftingTable
Spell
calcular
(
Stack
::
a
,
b
)
->
Stack
PolloCrudo
Stack
resultado
=
a
+
b
;
respawn
resultado
;
PolloAsado
Ritual
mostrarMensaje
(
Spider
::
mensaje
)
PolloCrudo
dropperSpider
(
mensaje
)
;
PolloAsado
SpawnPoint
PolloCrudo
contador
=
5
;
target
contador
>
0
craft
hit
PolloCrudo
dropperSpider
(
"Contador positivo"
)
;
PolloAsado
Stack
resultado
=
contador
+
10
;
Stack
suma
=
calcular
(
5
,
10
)
;
;
PolloAsado
worldSave
WorldName
PruebaComBloque
:
Bedrock
Obsidian
Stack
MAX_LEVEL
100
;
Obsidian
Spider
VERSION
"1.0"
;
Inventory
Stack
contador
=
0
;
Spider
texto
=
"Notch Engine"
;
Rune
inicial
;
Stack
a
=
10
,
b
=
20
;
Recipe
Spell
calcular
(
Stack
::
a
,
b
)
->
Stack
;
CraftingTable
Spell
calcular
(
Stack
::
a
,
b
)
->
Stack
PolloCrudo
Stack
resultado
=
a
+
b
;
respawn
resultado
;
PolloAsado
Ritual
mostrarMensaje
(
Spider
::
mensaje
)
PolloCrudo
dropperSpider
(
mensaje
)
;
PolloAsado
SpawnPoint
PolloCrudo
contador
=
5
+
10
;
target
contador
>
0
craft
hit
PolloCrudo
dropperSpider
(
"Contador positivo"
)
;
PolloAsado
dentro
pero
sin
cerrar
aún
*
secuencias
*
PolloAsado
worldSave
WorldName
PruebaComentarios
:
Inventory
Stack
contador
=
10
;
Spider
texto
=
"Comentario /* falso */ dentro de un string"
;
Rune
caracter
=
'*'
;
SpawnPoint
PolloCrudo
dropperSpider
(
"Los comentarios son importantes"
)
;
PolloAsado
worldSave
WorldName
PruebaIdentificadoresSimples
:
Bedrock
Obsidian
Stack
MAX
100
;
Obsidian
Spider
TITULO
"Notch Engine"
;
Inventory
Stack
a
;
Stack
contador
;
Stack
nivel
;
Stack
x
;
Stack
y
;
Stack
z
;
Stack
posicion
;
Stack
altura
;
Stack
ancho
;
Spider
nombre
;
Spider
texto
;
Spider
mensaje
;
Spider
saludo
;
Torch
activo
;
Torch
visible
;
Torch
terminado
;
Rune
inicial
;
Rune
caracter
;
Rune
simbolo
;
Ghast
pi
;
Ghast
temperatura
;
Ghast
velocidad
;
Stack
Contador
;
Spider
Nombre
;
Torch
Activo
;
Stack
i
;
Stack
j
;
Stack
k
;
Rune
c
;
Spider
s
;
Torch
b
;
Ghast
f
;
CraftingTable
Spell
suma
(
Stack
::
a
,
b
)
->
Stack
PolloCrudo
Stack
resultado
;
resultado
=
a
+
b
;
respawn
resultado
;
PolloAsado
Ritual
imprimir
(
Spider
::
mensaje
)
PolloCrudo
dropperSpider
(
mensaje
)
;
PolloAsado
SpawnPoint
PolloCrudo
Stack
valor
;
Stack
resultado
;
Spider
mensaje
;
valor
=
10
;
mensaje
=
"Hola"
;
resultado
=
valor
+
5
;
valor
=
suma
(
valor
,
20
)
;
ender_pearl
imprimir
(
mensaje
)
;
PolloAsado
worldSave
WorldName
PruebaIdentificadoresComplejos
:
Bedrock
Obsidian
Stack
MAX_LEVEL
100
;
Obsidian
Stack
MIN_LEVEL
1
;
Obsidian
Spider
GAME_TITLE
"Notch Engine"
;
Obsidian
Spider
VERSION_1_0
"v1.0"
;
Inventory
Stack
player_level
;
Stack
enemy_count
;
Stack
max_health
;
Stack
min_damage
;
Stack
current_position_x
;
Stack
counter1
;
Stack
item2
;
Stack
level3d
;
Stack
position2d
;
Stack
player1_health
;
Stack
item_1
;
Stack
player_2_score
;
Stack
enemy_level_3
;
Stack
position_x_1
;
Stack
inventory_slot_5
;
Stack
_temp
;
Stack
_internal_counter
;
Stack
_system_value
;
Stack
_player_data
;
Stack
very_long_variable_name_with_many_words
;
Spider
extremely_long_message_text_that_describes_something_in_detail
;
Torch
is_player_currently_in_creative_mode_with_flight_enabled
;
Stack
player5_current_health_max_100
;
Stack
enemy_3d_position_coordinate_x_12
;
Rune
player_initial_1
;
Spider
user_5_name
;
CraftingTable
Spell
calculate_total_damage
(
Stack
::
base_damage
,
critical_multiplier
;
Torch
::
is_headshot
)
->
Stack
PolloCrudo
Stack
total_damage
;
total_damage
=
base_damage
*
critical_multiplier
;
target
is_headshot
craft
hit
PolloCrudo
total_damage
=
total_damage
*
2
;
PolloAsado
respawn
total_damage
;
PolloAsado
Ritual
display_player_stats
(
Spider
::
player_name
;
Stack
level_1
,
health_points_100
)
PolloCrudo
dropperSpider
(
"Player: "
bind
player_name
)
;
dropperSpider
(
"Level: "
bind
level_1
)
;
dropperSpider
(
"Health: "
bind
health_points_100
)
;
PolloAsado
SpawnPoint
PolloCrudo
Stack
player1_health
=
100
;
Stack
enemy_count_5
=
10
;
Spider
main_player_name
=
"Steve_123"
;
player1_health
=
player1_health
-
20
;
enemy_count_5
=
calculate_total_damage
(
10
,
2
,
On
)
;
ender_pearl
display_player_stats
(
main_player_name
,
5
,
player1_health
)
;
Stack
___special_value
=
42
;
dropperStack
(
___special_value
)
;
PolloAsado
worldSave
WorldName
PruebaIdentificadoresSimilares
:
Bedrock
Obsidian
Stack
WorldNameTest
100
;
Obsidian
Spider
BedrockType
"Hard Stone"
;
Obsidian
Torch
InventoryFull
On
;
Inventory
Stack
worldname
;
Stack
WorldName2
;
Stack
bedrock
;
Stack
Bedrock_Type
;
Stack
inventory
;
Stack
InventorySlot
;
Stack
recipe
;
Stack
RecipeBook
;
Stack
craftingtable
;
Stack
CraftingTable2
;
Stack
spawnpoint
;
Stack
SpawnPoint_Main
;
Stack
stack
;
Spider
spider
;
Torch
torch
;
Rune
rune
;
Ghast
ghast
;
Chest
chest
;
Book
book
;
Stack
pollocrudo
;
Stack
PolloAsado
;
Stack
polloAsadoExtra
;
Stack
repeater
;
Stack
target
;
Stack
hit
;
Stack
miss
;
Stack
craft
;
Stack
jukebox
;
Stack
disc
;
Stack
silence
;
Stack
spawner
;
Stack
exhausted
;
Stack
walk
;
Stack
set
;
Stack
to
;
Stack
step
;
Stack
wither
;
Stack
creeper
;
Stack
enderPearl
;
Stack
enderpearlitem
;
Stack
ragequit
;
Stack
spell
;
Stack
Spell_Cast
;
Stack
ritual
;
Stack
RitualCeremony
;
Stack
respawn
;
Stack
respawnPoint
;
Stack
ender_pearl
;
Stack
enderpearlTeleport
;
Stack
soulsand
;
Stack
SoulSandBlock
;
Stack
magma
;
Stack
MagmaBlock
;
Stack
and
;
Stack
andOperator
;
Stack
or
;
Stack
orGate
;
Stack
not
;
Stack
notOperator
;
Stack
xor
;
Stack
xorCalculation
;
Stack
is
;
Stack
isNot
;
Stack
isEqual
;
Torch
on
;
Torch
onSwitch
;
Torch
off
;
Torch
offState
;
Stack
hopper
;
Stack
hopperMinecart
;
Stack
dropper
;
Stack
dropperFunction
;
CraftingTable
Spell
worldNameGenerator
(
)
->
Spider
PolloCrudo
Spider
spawnpoint
=
"DefaultSpawn"
;
Stack
craft
=
10
;
Spider
ritual
=
"Magic"
;
respawn
"Generated"
;
PolloAsado
Ritual
craftingTableMaker
(
Spider
::
recipe
;
Stack
inventory
)
PolloCrudo
Stack
spell
=
20
;
Stack
worldname
=
30
;
Torch
on
=
Off
;
dropperSpider
(
"Crafting table ready"
)
;
PolloAsado
SpawnPoint
PolloCrudo
Stack
worldname
=
1
;
Stack
bedrock
=
2
;
Stack
inventory
=
3
;
Stack
recipe
=
4
;
Stack
craftingtable
=
5
;
Stack
spawnpoint
=
6
;
worldname
=
worldname
+
bedrock
;
inventory
=
craftingtable
*
spawnpoint
;
target
worldname
>
recipe
craft
hit
PolloCrudo
Spider
spell
=
"Magic"
;
dropperSpider
(
spell
)
;
PolloAsado
Spider
generatedName
=
worldNameGenerator
(
)
;
ender_pearl
craftingTableMaker
(
"New Recipe"
,
inventory
)
;
PolloAsado
worldSave
WorldName
PruebaStringsLargos
:
Inventory
Spider
string_normal
=
"Este es un string normal"
;
Spider
string_largo
=
"Este es un string extremadamente largo para probar cómo maneja el analizador léxico los tokens de gran tamaño. El propósito es verificar si el buffer del analizador puede manejar correctamente cadenas que exceden el tamaño típico. En Minecraft, los jugadores pueden construir estructuras enormes y elaboradas, similar a cómo este string se extiende más allá de los límites normales. Las cadenas largas son útiles para almacenar textos extensos como descripciones, historias, o mensajes de diálogo en juegos. Este string sigue creciendo para asegurar que supere los límites habituales de procesamiento del analizador léxico."
;
Spider
string_muy_largo
=
"Este string es aún más largo que el anterior, llegando a aproximadamente mil caracteres para poner realmente a prueba los límites del analizador léxico. En el desarrollo de compiladores, es importante verificar cómo responde el sistema ante casos extremos. Los buffers mal dimensionados podrían causar desbordamientos o truncamientos inesperados. En el mundo de Minecraft, esto sería comparable a construir una megaestructura que se extiende hasta los límites permitidos del mundo. Es crucial que el compilador maneje correctamente estos casos límite, ya que en aplicaciones reales, los usuarios pueden introducir textos extremadamente largos, como documentación, logs detallados, o incluso código generado automáticamente. Este string continúa creciendo, añadiendo más y más caracteres para asegurar que pruebe adecuadamente la capacidad del buffer del analizador léxico. Una implementación robusta debería ser capaz de manejar este token sin problemas, reconociéndolo correctamente como un único string literal, sin importar su longitud. El tamaño máximo debería estar limitado únicamente por la memoria disponible en el sistema, no por limitaciones arbitrarias en el diseño del analizador léxico. Este string sigue y sigue, añadiendo más palabras y caracteres, para garantizar que realmente ponga a prueba los límites del analizador."
;
Spider
string_con_escapes
=
"Este string incluye secuencias de escape como: \n nueva línea, \t tabulación, \" comillas dobles, \\ barra invertida, y otros caracteres especiales como !@#$%^&*()_+-={}[]|:;<>,.?/~`"
;
Spider
string_multilinea
=
"Línea 1\nLínea 2\nLínea 3\nLínea 4\nLínea 5\nLínea 6\nLínea 7\nLínea 8\nLínea 9\nLínea 10\nLínea 11\nLínea 12\nLínea 13\nLínea 14\nLínea 15\nLínea 16\nLínea 17\nLínea 18\nLínea 19\nLínea 20"
;
Spider
string_simbolos
=
"Este string contiene símbolos que son tokens en Notch Engine: +, -, *, //, %, :+, :-, :*, :%, ://, @, [], {}, {: :}, {/ /}, >>. También incluye palabras reservadas como WorldName, Inventory, SpawnPoint, craft, respawn, soulsand, magma, etc."
;
Spider
string_extremo
=
"Este string es extremadamente largo AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA, superando los dos mil caracteres para realmente llevar al límite la capacidad del analizador léxico. En el desarrollo de compiladores e intérpretes, es fundamental probar cómo maneja el sistema casos extremos como este. Cualquier limitación no prevista en el diseño podría manifestarse al procesar tokens de este tamaño. En Minecraft, esto sería equivalente a construir una estructura colosal que se extiende por miles de bloques en todas direcciones, poniendo a prueba los límites del motor del juego. Los analizadores léxicos deben estar preparados para manejar tokens de cualquier longitud razonable, ya que en aplicaciones del mundo real, los usuarios pueden necesitar procesar textos extremadamente largos. Ejemplos incluyen el procesamiento de documentos completos, archivos de configuración extensos, o incluso código generado automáticamente que puede extenderse por miles de líneas. Este string sigue creciendo, añadiendo más y más palabras y caracteres, para asegurar que realmente ponga a prueba los límites del buffer del analizador. Una implementación robusta debería manejar este token sin problemas, reconociéndolo correctamente como un único string literal completo, sin importar su tamaño. El tamaño máximo debería estar limitado únicamente por la memoria disponible en el sistema, no por limitaciones arbitrarias en el diseño del analizador. Este string continúa expandiéndose, añadiendo más contenido para garantizar que supere cualquier buffer de tamaño fijo que pueda haber sido implementado. Es importante también verificar que el rendimiento del analizador no se degrade exponencialmente con tokens muy grandes, lo que podría indicar algoritmos ineficientes. En el contexto de Notch Engine, inspirado en Minecraft, este string sería como un libro dentro del juego con una historia increíblemente detallada que se extiende por múltiples páginas. El analizador léxico debe procesar este token de manera eficiente, reconociéndolo como un único string literal y no fragmentándolo incorrectamente en múltiples tokens. Este string sigue creciendo, agregando más y más caracteres, para asegurar que realmente ponga a prueba los límites del analizador léxico. Continúa expandiéndose, como un mundo de Minecraft que se genera infinitamente, añadiendo más palabras y frases para llegar a una longitud verdaderamente extrema. Este string sigue y sigue y sigue, desafiando las capacidades del analizador, probando su robustez y eficiencia al manejar casos extremos como este."
;
SpawnPoint
PolloCrudo
dropperSpider
(
"Prueba de strings largos completada"
)
;
Stack
longitud
=
#
(
string_largo
)
;
dropperStack
(
longitud
)
;
Spider
subcadena
=
from
string_largo
#
#
0
#
#
50
;
dropperSpider
(
subcadena
)
;
PolloAsado
worldSave
WorldName
PruebaNumeroGrande
:
Bedrock
Obsidian
Stack
NUM_PEQUENO
42
;
Obsidian
Stack
NUM_MEDIANO
12345
;
Obsidian
Stack
NUM_GRANDE
9876543210
;
Obsidian
Stack
NUM_MUY_GRANDE
1234567890123456789
;
Obsidian
Stack
NEG_PEQUENO
-
42
;
Obsidian
Stack
NEG_MEDIANO
-
12345
;
Obsidian
Stack
NEG_GRANDE
-
9876543210
;
Obsidian
Stack
NEG_MUY_GRANDE
-
1234567890123456789
;
Obsidian
Stack
INT_16BIT_MAX
32767
;
Obsidian
Stack
INT_16BIT_MIN
-
32768
;
Obsidian
Stack
INT_32BIT_MAX
2147483647
;
Obsidian
Stack
INT_32BIT_MIN
-
2147483648
;
Obsidian
Stack
INT_64BIT_MAX
9223372036854775807
;
Obsidian
Stack
INT_64BIT_MIN
-
9223372036854775808
;
Obsidian
Stack
NUM_EXTREMO
123456789012345678901234567890
;
Obsidian
Stack
NEG_EXTREMO
-
123456789012345678901234567890
;
Inventory
Stack
num1
=
1234567890
;
Stack
num2
=
9876543210
;
Stack
grande1
=
123456789012345678
;
Stack
grande2
=
987654321098765432
;
Stack
max16
=
32767
;
Stack
min16
=
-
32768
;
Stack
max32
=
2147483647
;
Stack
min32
=
-
2147483648
;
Stack
max64
=
9223372036854775807
;
Stack
min64
=
-
9223372036854775808
;
Stack
extremo
=
123456789012345678901234567890
;
Shelf
[
2147483647
]
Stack
arregloGrande
;
Stack
suma
;
Stack
resta
;
Stack
multiplicacion
;
Stack
division
;
Stack
modulo
;
SpawnPoint
PolloCrudo
suma
=
num1
+
num2
;
resta
=
num2
-
num1
;
multiplicacion
=
num1
*
10
;
division
=
num2
10
;
modulo
=
num2
%
10
;
Stack
resultado1
=
grande1
+
grande2
;
Stack
resultado2
=
extremo
1000
;
Stack
posible_overflow
=
max32
+
1
;
Stack
posible_underflow
=
min32
-
1
;
Stack
producto_grande
=
grande1
*
grande2
;
Stack
division_extrema
=
extremo
3
;
dropperStack
(
suma
)
;
dropperStack
(
resta
)
;
dropperStack
(
multiplicacion
)
;
dropperStack
(
division
)
;
target
producto_grande
>
0
craft
hit
PolloCrudo
dropperSpider
(
"El resultado es positivo"
)
;
PolloAsado
Stack
i
=
0
;
repeater
i
<
5
craft
PolloCrudo
dropperStack
(
i
)
;
dropperStack
(
grande1
)
;
soulsand
i
;
PolloAsado
PolloAsado
worldSave
WorldName
PruebaPrecisionFlotante
:
Bedrock
Obsidian
Ghast
PI_SIMPLE
3.14
;
Obsidian
Ghast
PI_PRECISO
3.14159265358979323846
;
Obsidian
Ghast
EULER
2.71828182845904523536
;
Obsidian
Ghast
RAIZ_DOS
1.41421356237309504880
;
Obsidian
Ghast
PHI
1.61803398874989484820
;
Obsidian
Ghast
SPEED_OF_LIGHT
2.99792458
e8
;
Obsidian
Ghast
PLANCK_CONSTANT
6.62607015
e
-
34
;
Obsidian
Ghast
AVOGADRO
6.02214076
e23
;
Obsidian
Ghast
EXTREMO_PEQUENO
0.0000000000000000000000001
;
Obsidian
Ghast
EXTREMO_GRANDE
123456789012345678901234.5678901234567890
;
Obsidian
Ghast
NEG_PI
-
3.14159265358979
;
Obsidian
Ghast
NEG_EXTREMO
-
0.0000000000000000000000001
;
Obsidian
Ghast
CERO_DECIMAL
0.0
;
Obsidian
Ghast
SOLO_ENTERO
42.0
;
Obsidian
Ghast
SOLO_DECIMAL
0.42
;
Obsidian
Ghast
PUNTO_INICIAL
.
5
;
Inventory
Ghast
normal
=
3.14
;
Ghast
preciso
=
3.141592653589793
;
Ghast
pequeno
=
0.000000000123
;
Ghast
grande
=
1234567890.123456789
;
Ghast
punto_inicial
=
.
25
;
Ghast
sin_decimal
=
42
.
;
Ghast
cientifico1
=
1.23
e5
;
Ghast
cientifico2
=
4.56
e
-
7
;
Ghast
cientifico3
=
7.89
e
+
12
;
Ghast
muy_pequeno
=
0.000000000000000000000000000000000001
;
Ghast
muy_grande
=
999999999999999999999999999999999999999.9
;
Ghast
muchos_digitos
=
123456789012345.678901234567890
;
Ghast
neg_normal
=
-
3.14
;
Ghast
neg_preciso
=
-
3.141592653589793
;
Ghast
neg_pequeno
=
-
0.000000000123
;
Ghast
neg_cientifico
=
-
2.998
e8
;
Ghast
resultado1
;
Ghast
resultado2
;
Ghast
resultado3
;
SpawnPoint
PolloCrudo
resultado1
=
normal
:
+
preciso
;
resultado2
=
preciso
:
-
normal
;
resultado3
=
normal
:
*
2.0
;
Ghast
res_extremo1
=
muy_pequeno
:
*
1000000.0
;
Ghast
res_extremo2
=
muy_grande
:
1000000.0
;
Ghast
division1
=
1.0
:
3.0
;
Ghast
division2
=
2.0
:
3.0
;
Ghast
division_extrema
=
1.0
:
9999999999.0
;
Ghast
res_cientifico
=
cientifico1
:
*
cientifico2
;
dropperGhast
(
resultado1
)
;
dropperGhast
(
resultado2
)
;
dropperGhast
(
division1
)
;
dropperGhast
(
division2
)
;
target
division1
:
<
0.34
craft
hit
PolloCrudo
dropperSpider
(
"La división 1/3 es menor que 0.34"
)
;
PolloAsado
Ghast
i
=
0.0
;
repeater
i
:
<
1.0
craft
PolloCrudo
dropperGhast
(
i
)
;
i
=
i
:
+
0.2
;
PolloAsado
PolloAsado
worldSave
WorldName
PruebaComentarioLargo
:
Inventory
Stack
contador
=
0
;
Stack
despues_comentario
=
1
;
Spider
mensaje
=
"Prueba de comentarios largos"
;
SpawnPoint
PolloCrudo
Stack
i
=
0
;
repeater
i
<
5
craft
PolloCrudo
soulsand
i
;
dropperSpider
(
mensaje
bind
" - iteración "
bind
i
)
;
PolloAsado
dropperSpider
(
"Prueba de comentarios largos completada"
)
;
PolloAsado
worldSave
WorldName
PruebaTokensConsecutivos
:
Bedrock
Obsidian
Stack
MAX_LEVEL5
100
;
Obsidian
Stack
LEVEL_PLUS_SKILL
200
;
Obsidian
Stack
OFFSET_MINUS_5
50
;
Inventory
Stack
a
=
5
;
Stack
b
=
10
;
Stack
c
=
a
+
b
;
Stack
suma
=
5
+
3
;
Stack
resta
=
10
-
7
;
Stack
multiplicacion
=
4
*
3
;
Stack
division
=
20
4
;
Stack
modulo
=
7
%
2
;
Torch
comparacion1
=
5
<
10
;
Torch
comparacion2
=
5
>
3
;
Torch
comparacion3
=
5
<=
5
;
Torch
comparacion4
=
5
>=
5
;
Torch
comparacion5
=
5
is5
;
Torch
comparacion6
=
5
isNot6
;
Stack
expr1
=
5
+
3
*
2
;
Stack
expr2
=
(
5
+
3
)
*
2
;
Stack
expr3
=
5
+
(
3
*
2
)
;
Ghast
f1
=
3.14
;
Ghast
f2
=
f1
:
+
2.5
;
Ghast
f3
=
f1
:
-
1.5
;
Ghast
f4
=
f1
:
*
2.0
;
Ghast
f5
=
f1
:
1.5
;
Shelf
[
5
]
Stack
arreglo
;
Entity
Jugador
PolloCrudo
Spider
nombre
;
Stack
nivel
;
PolloAsado
;
Spider
texto
=
"Hola"
;
Rune
caracter
=
'A'
;
Torch
booleano
=
On
;
Stack
arr
[
0
]
=
10
;
Stack
x
=
1
,
y
=
2
,
z
=
3
;
Stack
normal1
=
10
;
Stack
normal2
=
20
;
Spider
mensaje
=
"Tokens consecutivos"
;
SpawnPoint
PolloCrudo
suma
=
normal1
+
normal2
;
Stack
valor
=
(
normal1
+
5
)
*
(
normal2
-
5
)
;
repeater
suma
>
0
hit
PolloCrudo
suma
=
suma
-
1
;
dropperStack
(
suma
)
;
PolloAsado
target
valor
>=
100
hit
PolloCrudo
dropperSpider
(
"Valor grande"
)
;
PolloAsado
miss
PolloCrudo
dropperSpider
(
"Valor pequeño"
)
;
PolloAsado
dropperSpider
(
mensaje
)
;
dropperStack
(
valor
)
;
normal1
+
=
5
;
normal2
-
=
3
;
dropperStack
(
normal1
)
;
dropperStack
(
normal2
)
;
PolloAsado
worldSave
WorldName
PruebaCaracteresInvalidos
:
Bedrock
Obsidian
Stack
NORMAL
100
;
Obsidian
Stack
ÑANDU
200
;
Obsidian
Stack
AÇÚCAR
300
;
Obsidian
Stack
CAFÉ
400
;
Inventory
Stack
contador
=
0
;
Spider
mensaje
=
"Normal"
;
Stack
año
=
2025
;
Stack
piña
=
10
;
Spider
münzen
=
"Monedas"
;
Spider
öffentlich
=
"Público"
;
Stack
cont
ador
=
5
;
Spider
mens
aje
=
"Texto"
;
Stack
contador
=
10
;
Spider
mensaje
=
"Texto"
;
Stack
monedas
=
100
;
Stack
valor
=
50
;
Spider
texto
=
"Copyright"
;
Spider
texto_unicode
=
"Caracteres especiales: áéíóúñÁÉÍÓÚÑ"
;
Spider
texto_emoji
=
"Emojis: 😀🎮🌍💻"
;
Stack
a
b
;
Stack
c
d
;
Stack
e
f
;
Stack
g
h
;
Stack
valor
otro
;
Stack
valor
contador
=
5
;
Stack
otro
valor
=
10
;
Rune
char_1
=
'€'
;
Rune
char_2
=
'✓'
;
SpawnPoint
PolloCrudo
contador
=
1
;
contador
=
contador
2
;
contador
=
contador
2
;
dropperStack
(
año
)
;
dropperSpider
(
texto_unicode
)
;
contador
=
5
10
;
contador
=
5
10
;
contador
=
5
;
contador
=
contador
+
5
;
dropperSpider
(
"Fin de prueba"
)
;
PolloAsado
worldSave
WorldName
PruebaStringNoTerminado
:
Bedrock
Obsidian
Spider
NOMBRE
"Notch Engine"
;
Obsidian
Spider
VERSION
"1.0"
;
Obsidian
Spider
DESCRIPCION
"Un lenguaje basado en Minecraft;
$$ Constante después del error para verificar recuperación
Obsidian Stack MAX_NIVEL 100;
Inventory
$$ Variables con strings correctamente terminados
Spider normal = "
Este
string
está
bien
";
Spider multilinea = "
Este
string
tiene
nmúltiples
líneas
ny
está
bien
terminado
";
$$ Variable con string no terminado - falta comilla de cierre
Spider incompleto = "
Este
string
no
está
terminado
;
Stack
contador
=
0
;
Spider
confuso
=
"Este string tiene una comilla escapada \" pero no está terminado;
$$ String no terminado al final de una línea
Spider final_linea = "
Este
string
termina
la
línea
pero
no
está
cerrado
Spider
siguiente
=
"Este es un nuevo string"
;
Spider
combinado
=
"String no terminado Stack contador = 5;
$$ String con múltiples líneas pero sin terminar
Spider multilinea_incompleto = "
Este
string
tiene
múltiples
líneas
pero
no
está
terminado
correctamente
;
Spider
comentario_inmediato
=
"String terminado correctamente"
Spider
comentario_error
=
"String no terminado$$ Comentario que no salva el error
$$ String no terminado con comentario de bloque al final
Spider bloque_inmediato = "
String
no
terminado
Spider
consecutivo1
=
"Primer string terminado"
;
Spider
consecutivo2
=
"Segundo string no terminado;
Spider consecutivo3 = "
Tercer
string
terminado
";
SpawnPoint
PolloCrudo
$$ Código normal para contraste
dropperSpider("
Este
mensaje
está
bien
formado
");
$$ Instrucción con string no terminado
dropperSpider("
Este
mensaje
no
está
terminado
;
contador
=
1
;
Spider
resultado
=
normal
bind
"Parte no terminada;
$$ String no terminado en una estructura de control
target normal is "
Comparación
no
terminada
craft
hit
PolloCrudo
dropperSpider
(
"Este código nunca se ejecutará"
)
;
PolloAsado
dropperSpider
(
"String final no terminado
PolloAsado
worldSave
$*
Prueba_Err_ComentarioNoTerminado.ne
Propósito: Verificar detección de comentarios de bloque sin cierre
Fecha: 28/04/2025
*$
WorldName PruebaComentarioNoTerminado:
Bedrock
$$ Constantes normales para contraste
Obsidian Stack MAX_LEVEL 100;
$* Comentario de bloque correctamente cerrado *$
Obsidian Stack MIN_LEVEL 1;
$* Comentario de bloque sin cierre - falta el terminador *$
Obsidian Stack MEDIO_LEVEL 50;
Inventory
$$ Variables normales para contraste
Stack contador = 0;
Spider mensaje = "
Hola
Mundo
";
$*
Comentario de bloque multi-línea correctamente terminado
con varias líneas de texto
*$
Stack variable_normal = 5;
$*
Comentario de bloque multi-línea sin terminar
Este comentario no tiene el terminador correspondiente
y debería generar un error
Torch activo = On; $$ Esta línea no debería ser reconocida como código
Stack valor = 10; $$ Esta línea no debería ser reconocida como código
$$ Variables después del error para verificar recuperación
Stack recuperacion = 20;
$* Otro comentario no terminado
con símbolos que podrían confundir al analizador:
* asterisco suelto
$ signo dólar suelto
*$ esto parece un terminador pero no lo es
$* esto parece un iniciador dentro del comentario
$$ Más código después del segundo comentario no terminado
Torch otra_variable = Off;
$* Comentario aparentemente cerrado, pero con un espacio entre * y $
que debería causar que no se reconozca como terminador * $
$$ Código después del tercer comentario no terminado
Stack tercera_recuperacion = 30;
$*
Este comentario tiene una secuencia que parece un terminador,
pero tiene caracteres en medio: *texto$
Por lo tanto, no está realmente terminado.
$$ Último código para verificar recuperación
Stack ultima_recuperacion = 40;
SpawnPoint
PolloCrudo
$$ Código normal para contraste
dropperSpider("
Inicio
de
programa
");
$* Comentario de bloque sin terminar en el SpawnPoint
Esta sección del código no debería ejecutarse
contador = 5;
dropperStack(contador);
$$ Código después del comentario no terminado
Stack final = 100;
dropperStack(final);
dropperSpider("
Fin
de
programa
");
PolloAsado
$$ Esto debería ser código después del SpawnPoint, que no es válido
$$ pero el analizador léxico igual debería procesarlo como tokens
$*
Comentario final sin terminar
Este es el último elemento del archivo
worldSave
$*
Prueba: 37_Prueba_Err_CaracterNoTerminado
Descripción: Verificar detección de literales de carácter sin cierre
Fecha: 28/04/2025
*$
WorldName PruebaCaracterNoTerminado:
Inventory
$$ Casos de caracteres correctamente formados (para comparación)
Rune letraCorrecta = 'A';
Rune digitoCorrecto = '5';
Rune simboloCorrecto = '@';
Rune escapeCorrecto = '\n';
$$ Casos de caracteres sin cierre (errores léxicos)
Rune errorSimple = 'B; $$ Falta comilla de cierre
Rune errorEscape = '\n; $$ Falta comilla de cierre después de secuencia de escape
$$ Caso con apertura pero sin contenido ni cierre
Rune errorVacio = '; $$ Solo comilla de apertura
$$ Caso con múltiples caracteres (error léxico)
Rune errorMultiple = 'ABC; $$ Múltiples caracteres y falta comilla de cierre
$$ Error dentro de una expresión
Stack valor = 5 + (3 * 'x); $$ Falta comilla de cierre en la expresión
SpawnPoint
PolloCrudo
$$ Este carácter inválido debería ser detectado
Rune pruebaError = 'Z;
dropperSpider("
Este
texto
no
debería
ser
alcanzado
debido
al
error
léxico
");
PolloAsado
worldSave
$*
Prueba: 38_Prueba_Err_SimboloDesconocido
Descripción: Verificar detección de símbolos no reconocidos
Fecha: 28/04/2025
*$
WorldName PruebaSimboloDesconocido:
Bedrock
$$ Símbolos válidos para comparación
Obsidian Stack MAX_VALUE 100;
$$ Símbolo no reconocido: flecha de asignación errónea
Obsidian Stack MIN_VALUE => 0; $$ => no es un símbolo válido
Inventory
$$ Símbolos válidos (para comparación)
Stack contador = 10;
Stack resultado = contador + 5;
$$ Símbolos no reconocidos
Stack valor1 = 5 ^ 2; $$ ^ (potencia) no es un símbolo válido
Stack valor2 = 10 \ 3; $$ \ no es un operador válido
Stack valor3 = valor1 ~ valor2; $$ ~ no es un operador válido
$$ Operadores malformados o incompletos
Stack valor4 = 3 : 4; $$ : solo no es un operador válido (debe ser :+, :-, etc.)
Stack valor5 = 7 / 2; $$ / no es válido (debe ser // para división entera)
$$ Uso de símbolos de otros lenguajes
Stack valor6 = 5 ** 2; $$ ** (potencia en Python) no es válido
Torch condicion = (valor5 == valor6); $$ == no es válido (debe ser 'is')
$$ Símbolo inválido en acceso a estructura
Stack elemento = numeros->0; $$ -> no es válido para acceso (debe ser [])
ResourcePack
$$ Símbolo inválido en declaración de tipo
Anvil Stack ==> Spider; $$ ==> no es un símbolo válido (debe ser ->)
SpawnPoint
PolloCrudo
$$ Operadores inválidos en expresiones
Stack a = 5;
Stack b = 10;
Stack c = a ||| b; $$ ||| no es un operador válido
$$ Símbolos inválidos en estructuras de control
target a < b craft hit
PolloCrudo
dropperSpider("
a
es
menor
que
b
");
PolloAsado
?> $$ ?> no es un símbolo válido
$$ Símbolo inválido como terminador de instrucción
Stack valor = 100#
PolloAsado
worldSave
$*
Prueba: 39_Prueba_Comb_Estructura
Descripción: Verificar estructura básica de un programa completo
Fecha: 28/04/2025
*$
WorldName PruebaEstructuraCompleta:
$$ Sección de constantes
Bedrock
Obsidian Stack MAX_NIVEL 100;
Obsidian Spider VERSION "
1.0
.
0
";
Obsidian Torch DEBUG_MODE Off;
Obsidian Ghast PI 3.14159;
$$ Sección de tipos
ResourcePack
Anvil Ghast -> Stack truncate;
Anvil Stack -> Spider;
$$ Definición de un tipo personalizado
Entity Jugador
PolloCrudo
Spider nombre;
Stack nivel;
Ghast salud;
Torch activo;
PolloAsado;
$$ Sección de variables
Inventory
$$ Variables básicas
Stack contador = 0;
Spider mensaje = "
Bienvenido
a
Notch
Engine
";
Torch juego_activo = On;
Ghast temperatura = 21.5;
Chest letras = {: 'a', 'b', 'c' :};
$$ Variables compuestas
Shelf[5] Stack inventario;
Entity Jugador steve;
$$ Sección de prototipos
Recipe
$$ Prototipo de función
Spell calcularDanio(Stack :: nivel, arma; Ghast ref multiplicador) -> Stack;
$$ Prototipo de procedimiento
Ritual mostrarEstado(Spider :: nombre; Stack nivel, salud);
$$ Sección de implementación de rutinas
CraftingTable
$$ Implementación de función
Spell calcularDanio(Stack :: nivel, arma; Ghast ref multiplicador) -> Stack
PolloCrudo
Stack danio_base = nivel * 2;
target arma is 1 hit
PolloCrudo
danio_base *= 2; $$ Arma mejorada
PolloAsado
multiplicador = 1.5; $$ Modificar parámetro por referencia
respawn danio_base;
PolloAsado
$$ Implementación de procedimiento
Ritual mostrarEstado(Spider :: nombre; Stack nivel, salud)
PolloCrudo
dropperSpider("
==
==
=
Estado
del
Jugador
==
==
=
");
dropperSpider("
Nombre
:
" bind nombre);
dropperSpider("
Nivel
:
" bind nivel);
dropperSpider("
Salud
:
" bind salud);
dropperSpider("
==
==
==
==
==
==
==
==
==
==
==
==
==
==
=
");
PolloAsado
$$ Punto de entrada del programa
SpawnPoint
PolloCrudo
$$ Inicialización
steve@nombre = "
Steve
";
steve@nivel = 1;
steve@salud = 20.0;
steve@activo = On;
$$ Entrada y salida
dropperSpider(mensaje);
dropperSpider("
Ingrese
su
nombre
:
");
Spider nombre_jugador = hopperSpider();
$$ Uso de estructuras de control
target #(nombre_jugador) > 0 hit
PolloCrudo
dropperSpider("
Hola
,
" bind nombre_jugador bind "
");
$$ Uso de funciones y procedimientos
Stack danio = calcularDanio(steve@nivel, 1, 1.0);
dropperSpider("
Tu
daño
base
es
:
" bind danio);
ender_pearl mostrarEstado(steve@nombre, steve@nivel, steve@salud);
$$ Bucle
repeater juego_activo
PolloCrudo
dropperSpider("
Continuar
jugando
(
On
Off
)
");
juego_activo = hopperTorch();
target juego_activo hit
PolloCrudo
soulsand steve@nivel;
dropperSpider("
Nivel
aumentado
a
:
" bind steve@nivel);
PolloAsado
PolloAsado
PolloAsado
miss
PolloCrudo
dropperSpider("
Nombre
no
válido
.
");
PolloAsado
$$ Otros tipos de bucles
Stack i = 0;
spawner
PolloCrudo
soulsand i;
inventario[i] = i * 10;
PolloAsado
exhausted i >= 5;
walk j set 0 to 4
PolloCrudo
dropperSpider("
Inventario
[
" bind j bind "
]
:
" bind inventario[j]);
PolloAsado
PolloAsado
worldSave
$*
Prueba: 40_Prueba_Comb_Declaraciones
Descripción: Verificar combinaciones de declaraciones de variables y constantes
Fecha: 28/04/2025
*$
WorldName PruebaCombinacionDeclaraciones:
$$ Sección de constantes con diferentes tipos y complejidades
Bedrock
$$ Constantes simples de tipos básicos
Obsidian Stack MAX_PLAYERS 8;
Obsidian Stack MIN_LEVEL 1;
Obsidian Torch DEBUG_MODE On;
Obsidian Spider GAME_TITLE "
Notch
Engine
";
Obsidian Rune SEPARATOR '_';
Obsidian Ghast GRAVITY 9.8;
$$ Constantes con expresiones
Obsidian Stack MAX_INVENTORY_SIZE 5 * 9;
Obsidian Stack TOTAL_SLOTS MAX_PLAYERS * MAX_INVENTORY_SIZE;
Obsidian Spider FULL_TITLE GAME_TITLE bind "
v1
.
0
";
Obsidian Ghast TERMINAL_VELOCITY GRAVITY :* 3.0;
$$ Constantes con expresiones más complejas
Obsidian Stack DAYS_IN_YEAR 365;
Obsidian Stack DAYS_IN_4_YEARS DAYS_IN_YEAR * 4 + 1;
Obsidian Torch IS_LEAP_YEAR (DAYS_IN_4_YEARS - (DAYS_IN_YEAR * 4)) is 1;
$$ Declaraciones de tipos con diferentes formas
ResourcePack
$$ Conversiones de tipos básicas
Anvil Ghast -> Stack;
Anvil Ghast -> Stack truncate;
Anvil Stack -> Spider;
Anvil Rune -> Stack safe;
$$ Declaraciones de entidades (registros)
Entity Item
PolloCrudo
Spider nombre;
Stack cantidad;
Stack durabilidad;
Torch stackeable;
PolloAsado;
Entity Jugador
PolloCrudo
Spider nombre;
Stack nivel;
Stack experiencia;
Ghast salud;
Ghast hambre;
Torch en_linea;
Entity Item item_principal;
PolloAsado;
Entity Posicion
PolloCrudo
Stack x;
Stack y;
Stack z;
PolloAsado;
$$ Tipos anidados
Entity Mundo
PolloCrudo
Spider nombre;
Stack seed;
Shelf[10] Entity Jugador jugadores;
Entity Posicion spawn;
PolloAsado;
$$ Sección de variables con diferentes formas de declaración e inicialización
Inventory
$$ Declaraciones simples sin inicialización
Stack contador;
Spider mensaje;
Torch estado;
Rune inicial;
Ghast temperatura;
$$ Declaraciones con inicialización
Stack nivel = 1;
Spider nombre = "
Steve
";
Torch activo = On;
Rune tecla = 'A';
Ghast pi = 3.14159;
$$ Declaraciones múltiples del mismo tipo
Stack x = 0, y = 0, z = 0;
Torch jugando = On, pausa = Off, sonido = On;
Ghast distancia = 0.0, velocidad = 5.0, aceleracion = 1.5;
$$ Declaraciones con resultados de expresiones
Stack suma = 5 + 10;
Stack producto = 4 * 25;
Spider saludo = "
Hola
" bind nombre;
Torch condicion = nivel > 5;
Ghast promedio = (10.5 :+ 20.7 :+ 15.3) :// 3.0;
$$ Declaraciones de tipos compuestos
Shelf[5] Stack inventario;
Shelf[3] Spider mensajes = ["
Hola
", "
Mundo
", "
"];
Shelf[2] Shelf[2] Stack matriz;
Chest numeros = {: 1, 2, 3, 4, 5 :};
Book archivo = {/ "
datos
.
txt
", 'E' /};
$$ Instancias de entidades (registros)
Entity Item espada;
Entity Jugador jugador1
PolloCrudo
nombre: "
Alex
";
nivel: 5;
experiencia: 150;
salud: 18.5;
hambre: 16.0;
en_linea: On;
item_principal:
PolloCrudo
nombre: "
Espada
de
diamante
";
cantidad: 1;
durabilidad: 1500;
stackeable: Off;
PolloAsado;
PolloAsado;
Entity Mundo mundo_principal;
SpawnPoint
PolloCrudo
$$ Inicialización de variables declaradas sin valor inicial
contador = 0;
mensaje = "
Variable
inicializada
en
el
punto
de
entrada
";
estado = Off;
inicial = 'Z';
temperatura = 22.5;
$$ Inicialización de variables compuestas
espada@nombre = "
Espada
de
hierro
";
espada@cantidad = 1;
espada@durabilidad = 250;
espada@stackeable = Off;
matriz[0][0] = 1;
matriz[0][1] = 2;
matriz[1][0] = 3;
matriz[1][1] = 4;
mundo_principal@nombre = "
Mundo
de
prueba
";
mundo_principal@seed = 12345;
mundo_principal@spawn@x = 0;
mundo_principal@spawn@y = 64;
mundo_principal@spawn@z = 0;
$$ Uso de constantes en asignaciones
Stack max_jugadores = MAX_PLAYERS;
dropperSpider(FULL_TITLE);
$$ Uso de referencias a variables en asignaciones
Stack total = nivel + jugador1@nivel;
dropperSpider("
Nivel
total
:
" bind total);
PolloAsado
worldSave
$*
Prueba: 41_Prueba_Comb_Expresiones
Descripción: Verificar expresiones aritméticas y lógicas complejas
Fecha: 28/04/2025
*$
WorldName PruebaExpresionesComplejas:
Bedrock
Obsidian Stack BASE_DAMAGE 10;
Obsidian Stack ARMOR_FACTOR 2;
Obsidian Ghast CRIT_MULTIPLIER 1.5;
Obsidian Torch USE_ADVANCED_FORMULAS On;
Inventory
$$ Variables para las pruebas
Stack a = 5;
Stack b = 10;
Stack c = 15;
Stack resultado_entero;
Ghast x = 2.5;
Ghast y = 3.7;
Ghast z = 1.2;
Ghast resultado_flotante;
Torch p = On;
Torch q = Off;
Torch r = On;
Torch resultado_logico;
Spider str1 = "
Notch
";
Spider str2 = "
Engine
";
Spider resultado_string;
Shelf[5] Stack valores = [10, 20, 30, 40, 50];
Entity Jugador
PolloCrudo
Spider nombre;
Stack nivel;
Ghast salud;
PolloAsado;
Entity Jugador jugador;
SpawnPoint
PolloCrudo
$$ 1. Expresiones aritméticas complejas con enteros
resultado_entero = a + b * c;
dropperSpider("
a
+
b
*
c
=
" bind resultado_entero);
resultado_entero = (a + b) * c;
dropperSpider("
(
a
+
b
)
*
c
=
" bind resultado_entero);
resultado_entero = a + b - c * 2 // 3 % 4;
dropperSpider("
a
+
b
-
c
*
2
3
%
4
=
" bind resultado_entero);
resultado_entero = (a + (b - (c * (2 // (3 % 4)))));
dropperSpider("
Anidada
enteros
:
" bind resultado_entero);
soulsand a;
resultado_entero = a + b;
magma b;
dropperSpider("
Después
de
incremento
decremento
:
" bind resultado_entero);
$$ 2. Expresiones aritméticas complejas con flotantes
resultado_flotante = x :+ y :* z;
dropperSpider("
x
:
+
y
:
*
z
=
" bind resultado_flotante);
resultado_flotante = (x :+ y) :* z;
dropperSpider("
(
x
:
+
y
)
:
*
z
=
" bind resultado_flotante);
resultado_flotante = x :+ y :- z :* 2.0 :// 0.5 :% 1.0;
dropperSpider("
x
:
+
y
:
-
z
:
*
2.0
:
0.5
:
%
1.0
=
" bind resultado_flotante);
resultado_flotante = (x :+ (y :- (z :* (2.0 :// (0.5 :% 1.0)))));
dropperSpider("
Anidada
flotantes
:
" bind resultado_flotante);
$$ 3. Expresiones lógicas complejas
resultado_logico = p and q;
dropperSpider("
p
and
q
=
" bind resultado_logico);
resultado_logico = p or q;
dropperSpider("
p
or
q
=
" bind resultado_logico);
resultado_logico = not p;
dropperSpider("
not
p
=
" bind resultado_logico);
resultado_logico = p xor q;
dropperSpider("
p
xor
q
=
" bind resultado_logico);
resultado_logico = p and q or r;
dropperSpider("
p
and
q
or
r
=
" bind resultado_logico);
resultado_logico = p and (q or r);
dropperSpider("
p
and
(
q
or
r
)
=
" bind resultado_logico);
resultado_logico = not (p and q) or (not r and p);
dropperSpider("
not
(
p
and
q
)
or
(
not
r
and
p
)
=
" bind resultado_logico);
$$ 4. Expresiones de comparación
resultado_logico = a < b;
dropperSpider("
a
<
b
=
" bind resultado_logico);
resultado_logico = a > c;
dropperSpider("
a
>
c
=
" bind resultado_logico);
resultado_logico = a <= b and b >= c;
dropperSpider("
a
<=
b
and
b
>=
c
=
" bind resultado_logico);
resultado_logico = (a is b) or (b is c);
dropperSpider("
(
a
is
b
)
or
(
b
is
c
)
=
" bind resultado_logico);
resultado_logico = a isNot b and b isNot c and a isNot c;
dropperSpider("
a
isNot
b
and
b
isNot
c
and
a
isNot
c
=
" bind resultado_logico);
$$ 5. Expresiones mixtas (combinando tipos)
resultado_logico = (a + b > c) and (x :+ y :> z);
dropperSpider("
(
a
+
b
>
c
)
and
(
x
:
+
y
:
>
z
)
=
" bind resultado_logico);
resultado_logico = (a < b) or (not p) and (x :< y);
dropperSpider("
(
a
<
b
)
or
(
not
p
)
and
(
x
:
<
y
)
=
" bind resultado_logico);
$$ 6. Expresiones con operaciones de cadenas
resultado_string = bind(str1, "
" bind str2);
dropperSpider("
bind
result
:
" bind resultado_string);
Stack longitud = #(resultado_string);
dropperSpider("
Length
:
" bind longitud);
resultado_string = from resultado_string ## 0 ## 5;
dropperSpider("
Substring
:
" bind resultado_string);
Stack pos = seek(resultado_string, "
tch
");
dropperSpider("
Position
of
'tch'
:
" bind pos);
$$ 7. Expresiones con accesos a estructuras
Stack valor_arreglo = valores[2] + valores[3] * valores[4];
dropperSpider("
Array
expression
:
" bind valor_arreglo);
jugador@nombre = "
Steve
";
jugador@nivel = 20;
jugador@salud = 18.5;
Stack nivel_con_bonus = jugador@nivel + 5;
dropperSpider("
Nivel
con
bonus
:
" bind nivel_con_bonus);
Torch nivel_alto = jugador@nivel > 15 and jugador@salud :> 15.0;
dropperSpider("
Nivel
alto
:
" bind nivel_alto);
$$ 8. Expresiones con conversiones de tipo
Stack entero_desde_float = x >> Stack;
dropperSpider("
Entero
desde
float
:
" bind entero_desde_float);
Torch bool_desde_entero = a >> Torch;
dropperSpider("
Booleano
desde
entero
:
" bind bool_desde_entero);
$$ 9. Expresiones extremadamente complejas que combinan múltiples elementos
Stack damage = BASE_DAMAGE + ((jugador@nivel // 2) * (valores[1] + valores[3] // 3));
dropperSpider("
Daño
calculado
:
" bind damage);
target USE_ADVANCED_FORMULAS craft hit
PolloCrudo
Ghast damage_final = ((damage >> Ghast) :* CRIT_MULTIPLIER) :// (1.0 :+ ((valores[4] // 10) >> Ghast));
dropperSpider("
Daño
final
(
fórmula
avanzada
)
:
" bind damage_final);
PolloAsado
miss
PolloCrudo
Stack damage_simple = damage * 2 // (ARMOR_FACTOR + (p and q >> Stack));
dropperSpider("
Daño
final
(
fórmula
simple
)
:
" bind damage_simple);
PolloAsado
PolloAsado
worldSave
$*
Prueba: 42_Prueba_Comb_Control.ne
Descripción: Verificar estructuras de control anidadas
Fecha: 28/04/2025
*$
WorldName PruebaControlAnidado:
Inventory
$$ Variables para las pruebas
Stack contador = 0;
Stack max_iteraciones = 5;
Stack resultado = 0;
Stack opcion = 2;
Torch condicion1 = On;
Torch condicion2 = Off;
Spider mensaje = "
Estructuras
de
control
anidadas
";
Spider resultado_texto = "
";
Shelf[5] Stack matriz = [1, 2, 3, 4, 5];
Entity Personaje
PolloCrudo
Spider nombre;
Stack nivel;
Torch activo;
PolloAsado;
Entity Personaje jugador;
SpawnPoint
dropperSpider(mensaje);
jugador@nombre = "
Steve
";
jugador@nivel = 1;
jugador@activo = On;
$$ 1. Condicionales anidados (if-then-else)
target jugador@nivel >= 1 craft hit
PolloCrudo
dropperSpider("
Nivel
suficiente
para
comenzar
");
target jugador@activo craft hit
PolloCrudo
dropperSpider("
Jugador
activo
");
target jugador@nombre is "
Steve
" craft hit
PolloCrudo
dropperSpider("
Bienvenido
,
Steve
");
soulsand jugador@nivel;
PolloAsado
miss
PolloCrudo
dropperSpider("
Bienvenido
,
jugador
desconocido
");
PolloAsado
PolloAsado
miss
PolloCrudo
dropperSpider("
Jugador
inactivo
.
Activando
.
.
.
");
jugador@activo = On;
PolloAsado
PolloAsado
miss
PolloCrudo
dropperSpider("
Nivel
insuficiente
para
comenzar
");
PolloAsado
$$ 2. Switch anidado dentro de if
target opcion > 0 craft hit
PolloCrudo
jukebox opcion craft
disc 1:
PolloCrudo
dropperSpider("
Opción
1
seleccionada
");
target condicion1 craft hit
PolloCrudo
dropperSpider("
Subopción
A
");
PolloAsado
miss
PolloCrudo
dropperSpider("
Subopción
B
");
PolloAsado
PolloAsado
disc 2:
PolloCrudo
dropperSpider("
Opción
2
seleccionada
");
jukebox jugador@nivel craft
disc 1:
PolloCrudo
dropperSpider("
Nivel
básico
");
PolloAsado
disc 2:
PolloCrudo
dropperSpider("
Nivel
intermedio
");
PolloAsado
silence:
PolloCrudo
dropperSpider("
Nivel
desconocido
");
PolloAsado
PolloAsado
silence:
PolloCrudo
dropperSpider("
Opción
no
reconocida
");
PolloAsado
PolloAsado
$$ 3. Bucles anidados - while dentro de for
walk i set 0 to 2 craft
PolloCrudo
dropperSpider("
Iteración
de
for
principal
:
" bind i);
Stack j = 0;
repeater j < 3 craft
PolloCrudo
dropperSpider("
Subiteración
de
while
:
" bind j);
resultado += (i * 10 + j);
soulsand j;
PolloAsado
PolloAsado
dropperSpider("
Resultado
acumulado
:
" bind resultado);
$$ 4. Bucle do-while con if anidado
contador = 0;
resultado = 0;
spawner
PolloCrudo
soulsand contador;
dropperSpider("
Iteración
do
-
while
:
" bind contador);
target contador % 2 is 0 craft hit
PolloCrudo
dropperSpider("
Número
par
detectado
");
resultado += contador;
PolloAsado
miss
PolloCrudo
dropperSpider("
Número
impar
detectado
");
resultado += contador * 2;
PolloAsado
PolloAsado
exhausted contador >= max_iteraciones;
dropperSpider("
Resultado
tras
do
-
while
:
" bind resultado);
$$ 5. Bucles for anidados con break y continue
resultado = 0;
walk i set 0 to 5 craft
PolloCrudo
target i is 3 craft hit
PolloCrudo
dropperSpider("
Saltando
iteración
i
=
3
");
enderPearl;
PolloAsado
dropperSpider("
For
externo
:
" bind i);
walk j set 0 to 3 craft
PolloCrudo
target i is 4 and j > 1 craft hit
PolloCrudo
dropperSpider("
Terminando
loop
interno
en
i
=
4
,
j
=
" bind j);
creeper;
PolloAsado
resultado += (i + j);
dropperSpider("
For
interno
:
j
=
" bind j bind "
,
suma
acumulada
=
" bind resultado);
PolloAsado
PolloAsado
$$ 6. Combinación compleja: with dentro de if-else dentro de while
contador = 0;
resultado = 0;
repeater contador < 3 craft
PolloCrudo
soulsand contador;
dropperSpider("
Iteración
while
principal
:
" bind contador);
target contador % 2 is 0 craft hit
PolloCrudo
wither jugador craft
PolloCrudo
activo = Off;
dropperSpider("
" bind nombre bind "
desactivado
temporalmente
");
spawner
PolloCrudo
soulsand nivel;
dropperSpider("
Incrementando
nivel
:
" bind nivel);
PolloAsado
exhausted nivel > contador + 2;
activo = On;
dropperSpider("
" bind nombre bind "
reactivado
con
nivel
" bind nivel);
PolloAsado
PolloAsado
miss
PolloCrudo
Stack temp_nivel = jugador@nivel;
repeater temp_nivel > 0 craft
PolloCrudo
dropperSpider("
Reduciendo
nivel
temporal
:
" bind temp_nivel);
target temp_nivel is 1 craft hit
PolloCrudo
dropperSpider("
Nivel
mínimo
alcanzado
");
creeper;
PolloAsado
magma temp_nivel;
PolloAsado
PolloAsado
PolloAsado
$$ 7. Estructuras de control con expresiones complejas en las condiciones
walk i set 0 to matriz[2] + matriz[4] // 2 craft
PolloCrudo
target (i * 2 <= matriz[i % 5]) and ((i % 2 is 0) or (i is matriz[0])) craft hit
PolloCrudo
dropperSpider("
Condición
compleja
satisfecha
en
i
=
" bind i);
resultado += i;
PolloAsado
PolloAsado
dropperSpider("
Resultado
final
:
" bind resultado);
$$ 8. Instrucción ragequit condicionada anidada
target contador >= max_iteraciones and resultado < 100 craft hit
PolloCrudo
target jugador@nivel < 5 craft hit
PolloCrudo
dropperSpider("
Condiciones
críticas
alcanzadas
.
Terminando
programa
.
");
ragequit;
PolloAsado
PolloAsado
dropperSpider("
Programa
completado
con
éxito
.
");
worldSave
$*
Prueba: 43_Prueba_Rend_MuchosTokens
Descripción: Verificar rendimiento con un archivo con miles de tokens
Fecha: 28/04/2025
*$
WorldName PruebaMuchosTokens:
Bedrock
Obsidian Stack MAX_ITERATIONS 1000;
Obsidian Stack ARRAY_SIZE 500;
Obsidian Stack STEP_VALUE 1;
Obsidian Spider TEST_NAME "
Prueba
de
rendimiento
con
muchos
tokens
";
ResourcePack
Entity TestData
PolloCrudo
Stack id;
Stack value;
Ghast weight;
Spider name;
Torch active;
PolloAsado;
Inventory
$$ Declaramos variables extensas para generar muchos tokens
Shelf[500] Stack numbers;
$$ Creamos un array grande de registros
Shelf[100] Entity TestData records;
$$ Variables para el procesamiento
Stack counter;
Stack sum;
Stack product;
Stack max_value;
Stack min_value;
Ghast average;
Stack i;
Stack j;
Stack k;
Stack temp;
Torch condition;
SpawnPoint
dropperSpider(TEST_NAME);
dropperSpider("
Inicializando
arrays
.
.
.
");
$$ Inicialización masiva del array de enteros
walk i set 0 to ARRAY_SIZE - 1 craft
PolloCrudo
numbers[i] = i * STEP_VALUE;
PolloAsado
$$ Inicialización del array de registros
walk i set 0 to 99 craft
PolloCrudo
records[i]@id = i;
records[i]@value = i * 10;
records[i]@weight = i :* 0.5;
records[i]@name = "
Item_
" bind i;
records[i]@active = i % 2 is 0;
PolloAsado
dropperSpider("
Realizando
cálculos
.
.
.
");
$$ Cálculos repetitivos generando miles de tokens
sum = 0;
product = 1;
max_value = numbers[0];
min_value = numbers[0];
$$ Bucle con muchas operaciones
walk i set 0 to ARRAY_SIZE - 1 craft
PolloCrudo
$$ Acumuladores simples
sum += numbers[i];
$$ Para evitar overflow, sólo multiplicamos los primeros 10 valores
target i < 10 craft hit
PolloCrudo
product *= numbers[i] + 1;
PolloAsado
$$ Cálculo de máximo y mínimo
target numbers[i] > max_value craft hit
PolloCrudo
max_value = numbers[i];
PolloAsado
target numbers[i] < min_value craft hit
PolloCrudo
min_value = numbers[i];
PolloAsado
$$ Operaciones condicionales adicionales
target i % 50 is 0 craft hit
PolloCrudo
dropperSpider("
Procesado
" bind i bind "
elementos
.
.
.
");
PolloAsado
PolloAsado
$$ Cálculo de promedio
average = sum >> Ghast :// (ARRAY_SIZE >> Ghast);
dropperSpider("
Procesamiento
completado
.
Resultados
:
");
dropperSpider("
Suma
total
:
" bind sum);
dropperSpider("
Producto
(
primeros
10
)
:
" bind product);
dropperSpider("
Valor
máximo
:
" bind max_value);
dropperSpider("
Valor
mínimo
:
" bind min_value);
dropperSpider("
Promedio
:
" bind average);
$$ Procesamiento de registros - para generar más tokens
dropperSpider("
Procesando
registros
.
.
.
");
counter = 0;
walk i set 0 to 99 craft
PolloCrudo
target records[i]@active craft hit
PolloCrudo
soulsand counter;
$$ Actualizar el valor basado en otros registros
walk j set 0 to i craft
PolloCrudo
records[i]@value += j;
PolloAsado
PolloAsado
PolloAsado
dropperSpider("
Registros
activos
:
" bind counter);
$$ Algoritmo de ordenamiento burbuja para generar aún más tokens
dropperSpider("
Ordenando
array
.
.
.
");
walk i set 0 to ARRAY_SIZE - 2 craft
PolloCrudo
walk j set 0 to ARRAY_SIZE - i - 2 craft
PolloCrudo
target numbers[j] > numbers[j + 1] craft hit
PolloCrudo
$$ Intercambio
temp = numbers[j];
numbers[j] = numbers[j + 1];
numbers[j + 1] = temp;
PolloAsado
PolloAsado
PolloAsado
dropperSpider("
Array
ordenado
.
");
$$ Búsqueda binaria para generar más tokens
dropperSpider("
Realizando
búsquedas
.
.
.
");
walk k set 0 to 20 craft
PolloCrudo
Stack valor_buscar = k * 25;
Stack inicio = 0;
Stack fin = ARRAY_SIZE - 1;
Stack medio;
Stack encontrado = 0;
repeater inicio <= fin craft
PolloCrudo
medio = (inicio + fin) // 2;
target numbers[medio] is valor_buscar craft hit
PolloCrudo
encontrado = 1;
creeper;
PolloAsado
target numbers[medio] < valor_buscar craft hit
PolloCrudo
inicio = medio + 1;
PolloAsado
miss
PolloCrudo
fin = medio - 1;
PolloAsado
PolloAsado
target encontrado craft hit
PolloCrudo
dropperSpider("
Valor
" bind valor_buscar bind "
encontrado
en
posición
" bind medio);
PolloAsado
miss
PolloCrudo
dropperSpider("
Valor
" bind valor_buscar bind "
no
encontrado
");
PolloAsado
PolloAsado
dropperSpider("
Prueba
de
rendimiento
completada
.
");
worldSave
$*
Prueba: 44_Prueba_Rend_TokensRepetidos
Descripción: Verificar rendimiento con patrones repetitivos
Fecha: 28/04/2025
*$
WorldName PruebaTokensRepetidos:
Bedrock
Obsidian Stack MAX_ITERATIONS 500;
Obsidian Stack PATTERN_LENGTH 20;
Inventory
$$ Variables para la prueba
Stack counter = 0;
Stack total = 0;
Stack temp = 0;
Torch flag = On;
SpawnPoint
dropperSpider("
Iniciando
prueba
de
rendimiento
con
tokens
repetitivos
");
$$ =================================================================
$$ Patrón 1: Repetición masiva de operaciones aritméticas
$$ =================================================================
counter = 0;
total = 0;
repeater counter < MAX_ITERATIONS craft
PolloCrudo
$$ Patrón de operaciones aritméticas que se repite
total = total + 1;
total = total - 1;
total = total + 2;
total = total - 1;
total = total + 3;
total = total - 2;
total = total * 2;
total = total // 2;
total = total + 5;
total = total % 10;
total = total + 1;
total = total - 1;
total = total + 2;
total = total - 1;
total = total + 3;
total = total - 2;
total = total * 2;
total = total // 2;
total = total + 5;
total = total % 10;
soulsand counter;
PolloAsado
dropperSpider("
Patrón
1
completado
.
Total
:
" bind total);
$$ =================================================================
$$ Patrón 2: Repetición masiva de operaciones lógicas
$$ =================================================================
counter = 0;
flag = On;
repeater counter < MAX_ITERATIONS craft
PolloCrudo
$$ Patrón de operaciones lógicas que se repite
flag = flag and On;
flag = flag or Off;
flag = not flag;
flag = flag and On;
flag = flag or Off;
flag = not flag;
flag = flag xor On;
flag = flag xor Off;
flag = flag and On;
flag = not flag;
flag = flag and On;
flag = flag or Off;
flag = not flag;
flag = flag and On;
flag = flag or Off;
flag = not flag;
flag = flag xor On;
flag = flag xor Off;
flag = flag and On;
flag = not flag;
soulsand counter;
PolloAsado
dropperSpider("
Patrón
2
completado
.
Estado
final
:
" bind flag);
$$ =================================================================
$$ Patrón 3: Repetición masiva de evaluaciones condicionales
$$ =================================================================
counter = 0;
total = 0;
repeater counter < MAX_ITERATIONS craft
PolloCrudo
$$ Patrón de condicionales que se repite
target counter % 2 is 0 craft hit
PolloCrudo
total += 1;
PolloAsado
miss
PolloCrudo
total += 2;
PolloAsado
target counter % 3 is 0 craft hit
PolloCrudo
total += 3;
PolloAsado
miss
PolloCrudo
total += 1;
PolloAsado
target counter % 5 is 0 craft hit
PolloCrudo
total += 5;
PolloAsado
miss
PolloCrudo
total += 2;
PolloAsado
target counter % 7 is 0 craft hit
PolloCrudo
total += 7;
PolloAsado
miss
PolloCrudo
total += 3;
PolloAsado
target total > 1000 craft hit
PolloCrudo
total = total % 1000;
PolloAsado
soulsand counter;
PolloAsado
dropperSpider("
Patrón
3
completado
.
Total
:
" bind total);
$$ =================================================================
$$ Patrón 4: Repetición masiva de incremento/decremento
$$ =================================================================
counter = 0;
total = 500;
repeater counter < MAX_ITERATIONS craft
PolloCrudo
$$ Patrón de incremento/decremento que se repite
soulsand total;
soulsand total;
soulsand total;
magma total;
magma total;
soulsand total;
soulsand total;
magma total;
soulsand total;
magma total;
soulsand total;
soulsand total;
soulsand total;
magma total;
magma total;
soulsand total;
soulsand total;
magma total;
soulsand total;
magma total;
soulsand counter;
PolloAsado
dropperSpider("
Patrón
4
completado
.
Total
:
" bind total);
$$ =================================================================
$$ Patrón 5: Repetición masiva de operaciones de asignación compuesta
$$ =================================================================
counter = 0;
total = 5;
repeater counter < MAX_ITERATIONS craft
PolloCrudo
$$ Patrón de asignaciones compuestas que se repite
total += 5;
total -= 2;
total *= 2;
total //= 2;
total %= 10;
total += 1;
total -= 1;
total *= 3;
total //= 3;
total %= 5;
total += 5;
total -= 2;
total *= 2;
total //= 2;
total %= 10;
total += 1;
total -= 1;
total *= 3;
total //= 3;
total %= 5;
soulsand counter;
PolloAsado
dropperSpider("
Patrón
5
completado
.
Total
:
" bind total);
$$ =================================================================
$$ Patrón 6: Repetición masiva de operadores de comparación
$$ =================================================================
counter = 0;
total = 0;
temp = 50;
repeater counter < MAX_ITERATIONS craft
PolloCrudo
$$ Patrón de comparaciones que se repite
target counter < temp craft hit total += 1; PolloAsado
target counter > temp craft hit total += 1; PolloAsado
target counter <= temp craft hit total += 1; PolloAsado
target counter >= temp craft hit total += 1; PolloAsado
target counter is temp craft hit total += 1; PolloAsado
target counter isNot temp craft hit total += 1; PolloAsado
target counter < 100 craft hit total += 1; PolloAsado
target counter > 0 craft hit total += 1; PolloAsado
target counter <= 100 craft hit total += 1; PolloAsado
target counter >= 0 craft hit total += 1; PolloAsado
target counter < temp craft hit total += 1; PolloAsado
target counter > temp craft hit total += 1; PolloAsado
target counter <= temp craft hit total += 1; PolloAsado
target counter >= temp craft hit total += 1; PolloAsado
target counter is temp craft hit total += 1; PolloAsado
target counter isNot temp craft hit total += 1; PolloAsado
target counter < 100 craft hit total += 1; PolloAsado
target counter > 0 craft hit total += 1; PolloAsado
target counter <= 100 craft hit total += 1; PolloAsado
target counter >= 0 craft hit total += 1; PolloAsado
soulsand counter;
PolloAsado
dropperSpider("
Patrón
6
completado
.
Total
:
" bind total);
dropperSpider("
Prueba
de
rendimiento
con
tokens
repetitivos
completada
.
");
worldSave
$*
Prueba: 45_Prueba_Rend_TokensVariados
Descripción: Verificar rendimiento con variedad de tokens mezclados
Fecha: 28/04/2025
*$
WorldName PruebaTokensVariados:
$$ Sección de constantes para controlar el tamaño de la prueba
Bedrock
Obsidian Stack ITERATIONS 100;
Obsidian Stack MAX_VALUE 1000;
Obsidian Stack ARRAY_SIZE 50;
Obsidian Spider TEST_NAME "
Prueba
de
rendimiento
con
tokens
variados
";
Obsidian Spider VERSION "
1.0
";
Obsidian Ghast PI 3.14159;
Obsidian Torch DEBUG_MODE On;
$$ Definiciones de tipos variados para generar diversidad de tokens
ResourcePack
Entity Posicion
PolloCrudo
Stack x;
Stack y;
Stack z;
PolloAsado;
Entity Item
PolloCrudo
Spider nombre;
Stack cantidad;
Stack durabilidad;
Ghast peso;
Torch consumible;
PolloAsado;
Entity Jugador
PolloCrudo
Spider nombre;
Stack nivel;
Ghast salud;
Entity Posicion posicion;
Shelf[10] Entity Item inventario;
PolloAsado;
Anvil Ghast -> Stack truncate;
Anvil Stack -> Spider;
Anvil Spider -> Stack;
Anvil Stack -> Torch;
Inventory
Stack contador = 0;
Stack suma = 0;
Stack producto = 1;
Ghast pi = 3.14159;
Ghast e = 2.71828;
Ghast resultado_flotante = 0.0;
Spider texto = "
Prueba
de
rendimiento
";
Spider resultado_texto = "
";
Rune caracter = 'A';
Torch condicion = On;
Shelf[ARRAY_SIZE] Stack numeros;
Shelf[ARRAY_SIZE] Ghast valores_reales;
Shelf[10] Spider textos = ["
uno
", "
dos
", "
tres
", "
cuatro
", "
cinco
", "
seis
", "
siete
", "
ocho
", "
nueve
", "
diez
"];
Chest conjunto_numeros = {: 1, 2, 3, 4, 5 :};
Chest conjunto_caracteres = {: 'a', 'b', 'c', 'd', 'e' :};
Book archivo_log = {/ "
log
.
txt
", 'E' /};
Book archivo_datos = {/ "
datos
.
dat
", 'L' /};
Entity Posicion origen
PolloCrudo
x: 0;
y: 0;
z: 0;
PolloAsado;
Entity Item espada
PolloCrudo
nombre: "
Espada
de
diamante
";
cantidad: 1;
durabilidad: 1000;
peso: 5.0;
consumible: Off;
PolloAsado;
Entity Jugador jugador_principal;
Entity Jugador jugadores[5];
Recipe
Spell calcularDanio(Stack :: nivel; Ghast :: multiplicador) -> Stack;
Spell distanciaEntre(Entity Posicion :: pos1, pos2) -> Ghast;
Spell crearItem(Spider :: nombre; Stack cantidad, durabilidad; Ghast peso; Torch consumible) -> Entity Item;
Ritual inicializarJugador(Entity Jugador ref jugador; Spider :: nombre; Stack nivel; Ghast salud);
Ritual mostrarEstadisticas(Entity Jugador :: jugador);
Ritual procesarInventario(Shelf[10] Entity Item :: inventario);
CraftingTable
Spell calcularDanio(Stack :: nivel; Ghast :: multiplicador) -> Stack
PolloCrudo
Stack danio_base = nivel * 2 + 5;
Stack danio_final = danio_base;
target nivel > 10 craft hit
PolloCrudo
danio_final += (nivel - 10) * 3;
PolloAsado
Ghast temp = danio_final >> Ghast;
temp = temp :* multiplicador;
danio_final = temp >> Stack;
respawn danio_final;
PolloAsado
Spell distanciaEntre(Entity Posicion :: pos1, pos2) -> Ghast
PolloCrudo
Stack dx = pos1@x - pos2@x;
Stack dy = pos1@y - pos2@y;
Stack dz = pos1@z - pos2@z;
Ghast dx_float = dx >> Ghast;
Ghast dy_float = dy >> Ghast;
Ghast dz_float = dz >> Ghast;
Ghast suma_cuadrados = (dx_float :* dx_float) :+ (dy_float :* dy_float) :+ (dz_float :* dz_float);
Ghast result = suma_cuadrados :// 2.0;
respawn result;
PolloAsado
Spell crearItem(Spider :: nombre; Stack cantidad, durabilidad; Ghast peso; Torch consumible) -> Entity Item
PolloCrudo
Entity Item nuevo_item
PolloCrudo
nombre: nombre;
cantidad: cantidad;
durabilidad: durabilidad;
peso: peso;
consumible: consumible;
PolloAsado;
respawn nuevo_item;
PolloAsado
Ritual inicializarJugador(Entity Jugador ref jugador; Spider :: nombre; Stack nivel; Ghast salud)
PolloCrudo
jugador@nombre = nombre;
jugador@nivel = nivel;
jugador@salud = salud;
jugador@posicion@x = 0;
jugador@posicion@y = 0;
jugador@posicion@z = 0;
walk i set 0 to 9 craft
PolloCrudo
jugador@inventario[i] = crearItem("
Item_
" bind i, i + 1, 100 * (i + 1), i :* 0.5, i % 2 is 0);
PolloAsado
PolloAsado
Ritual mostrarEstadisticas(Entity Jugador :: jugador)
PolloCrudo
dropperSpider("
==
=
Estadísticas
del
Jugador
==
=
");
dropperSpider("
Nombre
:
" bind jugador@nombre);
dropperSpider("
Nivel
:
" bind jugador@nivel);
dropperSpider("
Salud
:
" bind jugador@salud);
dropperSpider("
Posición
:
(
" bind jugador@posicion@x bind "
,
" bind jugador@posicion@y bind "
,
" bind jugador@posicion@z bind "
)
");
dropperSpider("
Inventario
:
" bind #(jugador@inventario) bind "
items
");
PolloAsado
Ritual procesarInventario(Shelf[10] Entity Item :: inventario)
PolloCrudo
Stack total_items = 0;
Ghast peso_total = 0.0;
Spider lista_items = "
";
walk i set 0 to 9 craft
PolloCrudo
total_items += inventario[i]@cantidad;
peso_total = peso_total :+ (inventario[i]@peso :* inventario[i]@cantidad >> Ghast);
target i < 9 craft hit
PolloCrudo
lista_items = lista_items bind inventario[i]@nombre bind "
,
";
PolloAsado
miss
PolloCrudo
lista_items = lista_items bind inventario[i]@nombre;
PolloAsado
PolloAsado
dropperSpider("
Total
items
:
" bind total_items);
dropperSpider("
Peso
total
:
" bind peso_total);
dropperSpider("
Lista
:
" bind lista_items);
PolloAsado
SpawnPoint
dropperSpider(TEST_NAME bind "
v
" bind VERSION);
walk i set 0 to ARRAY_SIZE - 1 craft
PolloCrudo
numeros[i] = (i * i + i) % MAX_VALUE;
valores_reales[i] = i :* PI :// 10.0;
target i < 20 craft hit
PolloCrudo
add(conjunto_numeros, i * 10);
PolloAsado
PolloAsado
jugador_principal@nombre = "
Aventurero
";
jugador_principal@nivel = 25;
jugador_principal@salud = 95.5;
jugador_principal@posicion@x = 100;
jugador_principal@posicion@y = 64;
jugador_principal@posicion@z = -50;
walk i set 0 to 4 craft
PolloCrudo
Spider nombre_jugador = "
Jugador_
" bind i;
Stack nivel_inicial = 1 + i * 5;
Ghast salud_inicial = 20.0 :+ (i :* 5.0);
ender_pearl inicializarJugador(jugadores[i], nombre_jugador, nivel_inicial, salud_inicial);
PolloAsado
dropperSpider("
Realizando
operaciones
mezcladas
.
.
.
");
contador = 0;
suma = 0;
producto = 1;
resultado_texto = "
";
walk iteracion set 0 to ITERATIONS - 1 craft
PolloCrudo
Stack indice = iteracion % ARRAY_SIZE;
suma += numeros[indice];
target producto < 1000000 craft hit
PolloCrudo
producto *= (indice + 1);
PolloAsado
Ghast valor_real = valores_reales[indice];
resultado_flotante = resultado_flotante :+ valor_real;
target resultado_flotante :> 1000.0 craft hit
PolloCrudo
resultado_flotante = resultado_flotante :% 1000.0;
PolloAsado
Spider texto_iteracion = textos[iteracion % 10];
target iteracion % 5 is 0 craft hit
PolloCrudo
resultado_texto = resultado_texto bind texto_iteracion;
PolloAsado
target iteracion % 2 is 0 craft hit
PolloCrudo
caracter = etchUp(caracter);
PolloAsado
miss
PolloCrudo
caracter = etchDown(caracter);
PolloAsado
condicion = condicion xor (iteracion % 3 is 0);
target indice % 2 is 0 and condicion craft hit
PolloCrudo
soulsand contador;
PolloAsado
target iteracion % 10 is 0 craft hit
PolloCrudo
Stack danio = calcularDanio(jugador_principal@nivel, 1.5);
Ghast distancia = distanciaEntre(jugador_principal@posicion, origen);
dropperSpider("
Iteración
" bind iteracion bind "
:
Daño
=
" bind danio bind "
,
Distancia
=
" bind distancia);
PolloAsado
Stack jugador_indice = iteracion % 5;
soulsand jugadores[jugador_indice]@nivel;
target iteracion % 20 is 0 craft hit
PolloCrudo
ender_pearl mostrarEstadisticas(jugadores[jugador_indice]);
PolloAsado
PolloAsado
dropperSpider("
Prueba
completada
.
Resultados
:
");
dropperSpider("
Suma
total
:
" bind suma);
dropperSpider("
Producto
acumulado
:
" bind producto);
dropperSpider("
Resultado
flotante
:
" bind resultado_flotante);
dropperSpider("
Texto
resultante
:
" bind resultado_texto);
dropperSpider("
Caracter
final
:
" bind caracter);
dropperSpider("
Contador
incrementado
:
" bind contador);
dropperSpider("
Estado
de
condición
final
:
" bind condicion);
ender_pearl procesarInventario(jugador_principal@inventario);
dropperSpider("
Prueba
de
rendimiento
con
tokens
variados
finalizada
");
worldSave
$*
Prueba_PR_Estructura.ne
Propósito: Verificar el reconocimiento de palabras reservadas de estructura del programa
Probar: WorldName, Bedrock, ResourcePack, Inventory, Recipe, CraftingTable, SpawnPoint
Fecha: 28/04/2025
*$
$$ Prueba de la estructura básica del programa NotchEngine
$$ Verificando las palabras reservadas: WorldName, Bedrock, ResourcePack, Inventory, Recipe, CraftingTable, SpawnPoint
WorldName PruebaEstructura:
Bedrock
Obsidian Stack MAX_VALOR 100;
Obsidian Spider SALUDO "
Prueba
de
estructura
";
ResourcePack
Anvil Stack -> Spider;
Inventory
Stack contador = 0;
Spider mensaje = "
Hola
mundo
";
Recipe
Spell sumar(Stack :: a, b) -> Stack;
Ritual mostrarMensaje(Spider :: texto);
CraftingTable
Spell sumar(Stack :: a, b) -> Stack
PolloCrudo
Stack resultado = a + b;
respawn resultado;
PolloAsado
Ritual mostrarMensaje(Spider :: texto)
PolloCrudo
dropperSpider(texto);
PolloAsado
SpawnPoint
PolloCrudo
dropperSpider(SALUDO);
Stack resultado = sumar(5, 10);
dropperSpider("
El
resultado
es
:
" bind resultado);
PolloAsado
worldSave
$*
Prueba_PR_Tipos.ne
Propósito: Verificar reconocimiento de tipos de datos en NotchEngine
Probar: Stack, Rune, Spider, Torch, Chest, Book, Ghast, Shelf, Entity
Fecha: 28/04/2025
*$
$$ Prueba de los tipos de datos en NotchEngine
$$ Verificando: Stack, Rune, Spider, Torch, Chest, Book, Ghast, Shelf, Entity
WorldName PruebaTipos:
Inventory
$$ Declaraciones de variables de cada tipo
$$ Stack - Tipo de dato entero
Stack entero = 42;
$$ Rune - Tipo de dato carácter
Rune caracter = 'N';
$$ Spider - Tipo de dato string
Spider texto = "
NotchEngine
";
$$ Torch - Tipo de dato booleano
Torch verdadero = On;
Torch falso = Off;
$$ Chest - Tipo de dato conjunto
Chest numeros = {: 1, 2, 3, 4, 5 :};
$$ Book - Tipo de dato archivo de texto
Book archivo = {/ "
datos
.
txt
", 'E' /};
$$ Ghast - Tipo de datos números flotantes
Ghast decimal = 3.14159;
$$ Shelf - Tipo de dato arreglos
Shelf[5] Stack arreglo = [1, 2, 3, 4, 5];
$$ Entity - Tipo de dato registros
Entity Jugador
PolloCrudo
Spider nombre;
Stack nivel;
Ghast salud;
PolloAsado;
Entity Jugador jugador = {nombre: "
Steve
", nivel: 1, salud: 20.0};
SpawnPoint
PolloCrudo
dropperSpider("
Prueba
de
tipos
completada
");
PolloAsado
worldSave
$*
Prueba_PR_Booleanos.ne
Propósito: Verificar reconocimiento de literales booleanas (On, Off)
Probar: Torch, And, Or, Not
Fecha: 28/04/2025
*$
$$ Prueba de literales booleanas en NotchEngine
$$ Verificando: On, Off
WorldName PruebaBooleanos:
Bedrock
Obsidian Torch VERDADERO On;
Obsidian Torch FALSO Off;
Inventory
$$ Declaración e inicialización con valores booleanos
Torch activo = On;
Torch inactivo = Off;
$$ Variables para almacenar resultados de operaciones lógicas
Torch resultado1;
Torch resultado2;
Torch resultado3;
Torch resultado4;
Torch resultado5;
SpawnPoint
PolloCrudo
$$ Mostrar valores booleanos directos
dropperSpider("
Valor
de
On
:
");
dropperTorch(On);
dropperSpider("
Valor
de
Off
:
");
dropperTorch(Off);
$$ Operaciones lógicas con literales booleanas
resultado1 = On and On;
dropperSpider("
On
and
On
:
");
dropperTorch(resultado1);
resultado2 = On and Off;
dropperSpider("
On
and
Off
:
");
dropperTorch(resultado2);
resultado3 = On or Off;
dropperSpider("
On
or
Off
:
");
dropperTorch(resultado3);
resultado4 = Off or Off;
dropperSpider("
Off
or
Off
:
");
dropperTorch(resultado4);
resultado5 = not On;
dropperSpider("
not
On
:
");
dropperTorch(resultado5);
$$ Uso en estructuras de control
target On craft hit
PolloCrudo
dropperSpider("
Condición
On
es
verdadera
");
PolloAsado
target Off craft hit
PolloCrudo
dropperSpider("
Esto
no
debería
mostrarse
");
PolloAsado
miss
PolloCrudo
dropperSpider("
Condición
Off
es
falsa
");
PolloAsado
PolloAsado
worldSave
$*
Prueba_PR_Bloques.ne
Propósito: Verificar reconocimiento de delimitadores de bloques (PolloCrudo, PolloAsado)
Probar: PolloCrudo, PolloAsado
Fecha: 28/04/2025
*$
$$ Prueba de delimitadores de bloques en NotchEngine
$$ Verificando: PolloCrudo, PolloAsado
WorldName PruebaBloques:
Inventory
$$ Variables para las pruebas
Stack contador = 0;
Stack acumulador = 0;
Stack resultado = 0;
Spider mensaje = "
Prueba
de
bloques
PolloCrudo
y
PolloAsado
";
CraftingTable
$$ Función con bloques de código
Spell sumarPares(Stack :: limite) -> Stack
PolloCrudo
Stack suma = 0;
$$ Bloque anidado dentro de una estructura de control
walk i set 1 to limite craft
PolloCrudo
target i % 2 is 0 craft hit
PolloCrudo
suma += i;
PolloAsado
PolloAsado
respawn suma;
PolloAsado
$$ Función con diferentes niveles de anidamiento de bloques
Spell calcularFactorial(Stack :: n) -> Stack
PolloCrudo
target n <= 1 craft hit
PolloCrudo
respawn 1;
PolloAsado
$$ Bloque dentro de una expresión
Stack resultado = n * calcularFactorial(n - 1);
respawn resultado;
PolloAsado
SpawnPoint
$$ Bloque principal
PolloCrudo
$$ Bloque simple
PolloCrudo
contador = 5;
dropperSpider(mensaje);
PolloAsado
$$ Bloque dentro de una estructura repeater
repeater contador > 0 craft
PolloCrudo
acumulador += contador;
magma contador;
$$ Bloque anidado dentro de un condicional dentro de un bucle
target contador is 2 craft hit
PolloCrudo
dropperSpider("
Contador
es
igual
a
2
");
$$ Otro bloque más anidado
PolloCrudo
dropperSpider("
Este
es
un
bloque
muy
anidado
");
PolloAsado
PolloAsado
PolloAsado
$$ Uso de bloques en estructura condicional
target acumulador > 10 craft hit
PolloCrudo
dropperSpider("
Acumulador
es
mayor
que
10
");
PolloAsado
miss
PolloCrudo
dropperSpider("
Acumulador
es
menor
o
igual
a
10
");
PolloAsado
$$ Bloque en estructura spawner-exhausted
spawner
PolloCrudo
soulsand resultado;
target resultado > 5 craft hit creeper;
PolloAsado
exhausted resultado > 10;
dropperSpider("
Valor
final
del
resultado
:
" bind resultado);
PolloAsado
worldSave
$*
Prueba_PR_Control.ne
Propósito: Verificar reconocimiento de palabras de control de flujo
Probar: Entity, PolloCrudo, PolloAsado, Punto, SpawnPoint, Inventory, WorldName
Fecha: 28/04/2025
*$
$$ Prueba de palabras reservadas de control de flujo en NotchEngine
$$ Verificando: repeater, craft, target, hit, miss, jukebox, disc, silence,
$$ spawner, exhausted, walk, set, to, step, wither
WorldName PruebaControl:
Inventory
$$ Variables para las pruebas
Stack contador = 0;
Stack opcion = 2;
Torch condicion = On;
Stack iterador = 0;
Entity Punto
PolloCrudo
Stack x;
Stack y;
PolloAsado;
Entity Punto coordenada;
SpawnPoint
PolloCrudo
$$ 1. Prueba de repeater (while) con craft
dropperSpider("
Prueba
de
repeater
:
");
contador = 5;
repeater contador > 0 craft
PolloCrudo
dropperStack(contador);
magma contador;
PolloAsado
$$ 2. Prueba de target (if) con hit y miss
dropperSpider("
Prueba
de
target
con
hit
y
miss
:
");
target condicion craft hit
PolloCrudo
dropperSpider("
Condición
es
verdadera
");
PolloAsado
miss
PolloCrudo
dropperSpider("
Condición
es
falsa
");
PolloAsado
$$ 3. Prueba de jukebox (switch) con disc y silence
dropperSpider("
Prueba
de
jukebox
con
disc
y
silence
:
");
jukebox opcion craft
disc 1:
PolloCrudo
dropperSpider("
Opción
1
seleccionada
");
PolloAsado
disc 2:
PolloCrudo
dropperSpider("
Opción
2
seleccionada
");
PolloAsado
silence:
PolloCrudo
dropperSpider("
Ninguna
opción
válida
seleccionada
");
PolloAsado
$$ 4. Prueba de spawner (do-while) con exhausted
dropperSpider("
Prueba
de
spawner
con
exhausted
:
");
contador = 0;
spawner
PolloCrudo
soulsand contador;
dropperStack(contador);
PolloAsado
exhausted contador >= 3;
$$ 5. Prueba de walk (for) con set, to, step
dropperSpider("
Prueba
de
walk
con
set
,
to
,
step
:
");
walk i set 0 to 10 step 2 craft
PolloCrudo
dropperStack(i);
PolloAsado
$$ 6. Prueba de wither (with)
dropperSpider("
Prueba
de
wither
:
");
coordenada@x = 10;
coordenada@y = 20;
wither coordenada craft
PolloCrudo
dropperSpider("
Coordenadas
:
(
" bind x bind "
,
" bind y bind "
)
");
PolloAsado
PolloAsado
worldSave
$*
Prueba_PR_Saltos.ne
Propósito: Verificar palabras para saltos y terminación (creeper, enderPearl, ragequit)
Fecha: 28/04/2025
*$
$$ Prueba de palabras reservadas para saltos y terminación en NotchEngine
$$ Verificando: creeper, enderPearl, ragequit
WorldName PruebaSaltos:
Inventory
$$ Variables para las pruebas
Stack contador = 0;
Stack totalPares = 0;
Stack totalImpares = 0;
Torch errorCritico = Off;
SpawnPoint
PolloCrudo
$$ 1. Prueba de creeper (break) para salir de un bucle
dropperSpider("
Prueba
de
creeper
(
break
)
:
");
walk i set 1 to 10 craft
PolloCrudo
dropperSpider("
Iteración
:
" bind i);
$$ Salimos del bucle cuando i llega a 5
target i is 5 craft hit
PolloCrudo
dropperSpider("
Encontrado
5
,
saliendo
del
bucle
con
creeper
");
creeper;
PolloAsado
PolloAsado
$$ 2. Prueba de enderPearl (continue) para saltar a la siguiente iteración
dropperSpider("
Prueba
de
enderPearl
(
continue
)
:
");
walk i set 1 to 10 craft
PolloCrudo
$$ Saltamos los números pares
target i % 2 is 0 craft hit
PolloCrudo
dropperSpider("
Número
par
" bind i bind "
,
saltando
con
enderPearl
");
enderPearl;
PolloAsado
$$ Esta parte solo se ejecuta para números impares
dropperSpider("
Procesando
número
impar
:
" bind i);
totalImpares += i;
PolloAsado
dropperSpider("
Total
de
números
impares
:
" bind totalImpares);
$$ 3. Prueba de creeper y enderPearl en bucles anidados
dropperSpider("
Prueba
de
control
de
flujo
en
bucles
anidados
:
");
walk i set 1 to 5 craft
PolloCrudo
walk j set 1 to 5 craft
PolloCrudo
$$ Saltar la iteración cuando j es 3
target j is 3 craft hit
PolloCrudo
dropperSpider("
Saltando
j
=
3
con
enderPearl
");
enderPearl;
PolloAsado
$$ Salir del bucle interno cuando j es 4
target j is 4 craft hit
PolloCrudo
dropperSpider("
Saliendo
del
bucle
interno
con
creeper
en
j
=
4
");
creeper;
PolloAsado
dropperSpider("
i
=
" bind i bind "
,
j
=
" bind j);
PolloAsado
PolloAsado
$$ 4. Prueba de ragequit (halt) para terminar el programa
$$ Nota: Esta parte debe estar comentada en pruebas reales
$$ o al final del programa, ya que detiene la ejecución
dropperSpider("
Prueba
de
ragequit
(
halt
)
:
");
target errorCritico craft hit
PolloCrudo
dropperSpider("
Error
crítico
detectado
,
terminando
programa
con
ragequit
");
$$ ragequit; $$ Comentado para evitar terminar la prueba
PolloAsado
dropperSpider("
Esta
línea
se
mostrará
si
errorCritico
es
Off
");
$$ Ejemplo descomentado pero que nunca se ejecutará
target Off craft hit
PolloCrudo
dropperSpider("
Esta
condición
nunca
se
cumple
");
ragequit;
PolloAsado
PolloAsado
worldSave
$*
Prueba_PR_Funciones.ne
Propósito: Verificar palabras para funciones y procedimientos (Spell, Ritual, respawn, ender_pearl)
Probar: Spell, Ritual, respawn, ender_pearl, crafting_table
Fecha: 28/04/2025
*$
$$ Prueba de palabras reservadas para funciones y procedimientos en NotchEngine
$$ Verificando: Spell, Ritual, respawn
WorldName PruebaFunciones:
$$ Sección de prototipos
Recipe
$$ Prototipos de funciones (Spell)
Spell sumar(Stack :: a, b) -> Stack;
Spell factorial(Stack :: n) -> Stack;
Spell esPar(Stack :: numero) -> Torch;
Spell sumarArreglo(Shelf[10] Stack :: numeros; Stack tamano) -> Stack;
$$ Prototipos de procedimientos (Ritual)
Ritual imprimirLinea(Spider :: texto);
Ritual mostrarResultado(Spider :: operacion; Stack valor);
Ritual imprimirArreglo(Shelf[10] Stack :: arr; Stack tamano);
$$ Sección de rutinas (implementación de funciones y procedimientos)
CraftingTable
$$ Funciones (Spell) con instrucción de retorno (respawn)
Spell sumar(Stack :: a, b) -> Stack
PolloCrudo
$$ Retorno con expresión simple
respawn a + b;
PolloAsado
Spell factorial(Stack :: n) -> Stack
PolloCrudo
$$ Retorno temprano con condición
target n <= 1 craft hit
PolloCrudo
respawn 1;
PolloAsado
$$ Retorno con expresión compleja y llamada recursiva
respawn n * factorial(n - 1);
PolloAsado
Spell esPar(Stack :: numero) -> Torch
PolloCrudo
target numero % 2 is 0 craft hit
PolloCrudo
respawn On;
PolloAsado
miss
PolloCrudo
respawn Off;
PolloAsado
PolloAsado
Spell sumarArreglo(Shelf[10] Stack :: numeros; Stack tamano) -> Stack
PolloCrudo
Stack suma = 0;
$$ Verificar parámetros
target tamano <= 0 craft hit
PolloCrudo
respawn 0; $$ Retorno temprano
PolloAsado
$$ Sumar elementos del arreglo
walk i set 0 to tamano - 1 craft
PolloCrudo
suma += numeros[i];
PolloAsado
respawn suma; $$ Retorno al final
PolloAsado
$$ Procedimientos (Ritual) con posibles retornos vacíos
Ritual imprimirLinea(Spider :: texto)
PolloCrudo
dropperSpider(texto);
dropperSpider("
--
--
--
--
--
--
--
--
--
--
--
--
");
PolloAsado
Ritual mostrarResultado(Spider :: operacion; Stack valor)
PolloCrudo
dropperSpider(operacion bind "
:
" bind valor);
$$ Retorno temprano sin valor
target valor < 0 craft hit
PolloCrudo
dropperSpider("
Valor
negativo
");
respawn; $$ Retorno vacío temprano
PolloAsado
dropperSpider("
Valor
válido
procesado
");
PolloAsado
Ritual imprimirArreglo(Shelf[10] Stack :: arr; Stack tamano)
PolloCrudo
target tamano <= 0 craft hit
PolloCrudo
dropperSpider("
Arreglo
vacío
");
respawn; $$ Retorno vacío temprano
PolloAsado
dropperSpider("
Elementos
del
arreglo
:
");
walk i set 0 to tamano - 1 craft
PolloCrudo
dropperStack(arr[i]);
PolloAsado
PolloAsado
$$ Punto de entrada con llamadas a funciones y procedimientos
SpawnPoint
PolloCrudo
$$ Declaración de variables
Stack a = 5;
Stack b = 7;
Stack resultado;
Shelf[10] Stack numeros;
$$ Inicializar arreglo
walk i set 0 to 9 craft
PolloCrudo
numeros[i] = i + 1;
PolloAsado
$$ Llamadas a funciones (invocación directa)
resultado = sumar(a, b);
dropperSpider("
Suma
:
" bind resultado);
resultado = factorial(5);
dropperSpider("
Factorial
de
5
:
" bind resultado);
Torch esPar5 = esPar(5);
dropperSpider("
Es
5
par
:
");
dropperTorch(esPar5);
resultado = sumarArreglo(numeros, 10);
dropperSpider("
Suma
del
arreglo
:
" bind resultado);
$$ Llamadas a procedimientos
imprimirLinea("
==
==
Resultados
de
pruebas
==
==
");
mostrarResultado("
Suma
de
5
y
7
", sumar(a, b));
mostrarResultado("
Valor
negativo
", -10);
imprimirArreglo(numeros, 5);
imprimirArreglo(numeros, 0);
PolloAsado
worldSave
$*
Prueba_PR_Operadores.ne
Propósito: Verificar operadores textuales reales en Notch Engine
Probar: soulsand, magma, and, or, not, xor, bind, #, from ##, except ##, seek,
add, drop, feed, map, biom, void, isEngraved, isInscribed, etchUp, etchDown,
unlock, lock, make, gather, forge, expand
Fecha: 28/04/2025
*$
WorldName PruebaOperadores:
Inventory {
Stack contador = 5; $$ Inicializa contador con 5
Torch condicion1 = On; $$ Condición 1 es verdadera
Torch condicion2 = Off; $$ Condición 2 es falsa
Torch resultado; $$ Variable para almacenar resultados booleanos
Spider texto1 = "
Notch
"; $$ Texto inicial "
Notch
"
Spider texto2 = "
Engine
"; $$ Texto inicial "
Engine
"
Spider textoCompleto; $$ Variable para texto combinado
Rune letra = 'a'; $$ Letra inicial 'a'
Rune letraMayuscula; $$ Variable para letra mayúscula
Chest conjunto1 = {: 1, 2, 3 :}; $$ Conjunto inicial con 1, 2, 3
Chest conjunto2 = {: 3, 4, 5 :}; $$ Conjunto inicial con 3, 4, 5
Chest conjuntoResultado; $$ Variable para resultado de conjuntos
Book archivo1 = {/ "
datos
.
txt
", 'E' /}; $$ Archivo para escritura "
datos
.
txt
"
Book archivo2 = {/ "
resultado
.
txt
", 'E' /}; $$ Archivo para escritura "
resultado
.
txt
"
Ghast flotante1 = 3.5; $$ Flotante inicial 3.5
Ghast flotante2 = 2.5; $$ Flotante inicial 2.5
Ghast resultadoFlotante; $$ Variable para resultado de operaciones flotantes
}
SpawnPoint {
PolloCrudo
$$ soulsand y magma
soulsand contador; $$ Aplica soulsand a contador
magma contador; $$ Aplica magma a contador
$$ and, or, not, xor
resultado = condicion1 and condicion2; $$ Resultado es verdadero si ambas condiciones son verdaderas
resultado = condicion1 or condicion2; $$ Resultado es verdadero si al menos una condición es verdadera
resultado = not condicion1; $$ Resultado es el opuesto de condicion1
resultado = condicion1 xor condicion2; $$ Resultado es verdadero si solo una condición es verdadera
$$ bind, #, from ##, except ##, seek
textoCompleto = bind(texto1, "
" bind texto2); $$ Combina texto1 y texto2 con un espacio
Stack longitud = #(textoCompleto); $$ Longitud de textoCompleto
Spider subcadena = from textoCompleto ## 0 ## 5; $$ Subcadena de textoCompleto desde 0 hasta 5
Spider sinNotch = except textoCompleto ## 0 ## 6; $$ Elimina caracteres de 0 a 6 en textoCompleto
Stack posicion = seek(textoCompleto, "
Engine
"); $$ Posición de "
Engine
" en textoCompleto
$$ isEngraved, isInscribed, etchUp, etchDown
Torch esLetra = isEngraved(letra); $$ Verifica si letra es una letra
Torch esDigito = isInscribed(letra); $$ Verifica si letra es un dígito
letraMayuscula = etchUp(letra); $$ Convierte letra a mayúscula
Rune letraMinuscula = etchDown(letraMayuscula); $$ Convierte letraMayuscula a minúscula
$$ Operaciones de conjuntos
add(conjunto1, 4); $$ Añade 4 a conjunto1
drop(conjunto1, 2); $$ Elimina 2 de conjunto1
conjuntoResultado = feed(conjunto1, conjunto2); $$ Intersección de conjunto1 y conjunto2
resultado = map(conjunto1, 3); $$ Verifica si 3 está en conjunto1
Torch conjuntoVacio = void(conjunto1); $$ Verifica si conjunto1 está vacío
$$ Operaciones de archivos
unlock(archivo1); $$ Abre archivo1 para escritura
forge(archivo1, "
Texto
de
prueba
"); $$ Escribe "
Texto
de
prueba
" en archivo1
lock(archivo1); $$ Cierra archivo1
Book nuevoArchivo = make({/ "
nuevo
.
txt
", 'E' /}); $$ Crea nuevo archivo "
nuevo
.
txt
"
forge(nuevoArchivo, "
Contenido
del
nuevo
archivo
"); $$ Escribe en nuevoArchivo
lock(nuevoArchivo); $$ Cierra nuevoArchivo
unlock(archivo1); $$ Abre archivo1
unlock(nuevoArchivo); $$ Abre nuevoArchivo
expand(archivo1, nuevoArchivo); $$ Expande archivo1 con contenido de nuevoArchivo
lock(archivo1); $$ Cierra archivo1
lock(nuevoArchivo); $$ Cierra nuevoArchivo
$$ Operadores de flotantes
resultadoFlotante = flotante1 :+ flotante2; $$ Suma de flotante1 y flotante2
resultadoFlotante = flotante1 :- flotante2; $$ Resta de flotante1 y flotante2
resultadoFlotante = flotante1 :* flotante2; $$ Multiplicación de flotante1 y flotante2
resultadoFlotante = flotante1 :// flotante2; $$ División de flotante1 y flotante2
resultadoFlotante = flotante1 :% flotante2; $$ Módulo de flotante1 y flotante2
PolloAsado
}
worldSave
$*
Prueba_Lit_Enteros.ne
Propósito: Verificar reconocimiento de literales enteros (positivos, negativos, cero)
Probar: Stack
Fecha: 28/04/2025
*$
$$ Prueba de literales enteros en NotchEngine
$$ Verificando: enteros positivos, negativos y cero
WorldName PruebaLitEnteros:
Bedrock
$$ Constantes enteras
Obsidian Stack CERO 0;
Obsidian Stack POSITIVO 42;
Obsidian Stack NEGATIVO -42;
Obsidian Stack MAX_VALOR 2147483647; $$ Valor máximo de 32 bits
Obsidian Stack MIN_VALOR -2147483648; $$ Valor mínimo de 32 bits
Inventory
$$ Variables con literales enteros
Stack cero = 0;
Stack uno = 1;
Stack diez = 10;
Stack cien = 100;
Stack mil = 1000;
Stack millon = 1000000;
$$ Enteros negativos
Stack negUno = -1;
Stack negDiez = -10;
Stack negCien = -100;
Stack negMil = -1000;
Stack negMillon = -1000000;
$$ Valor entero máximo y mínimo (aproximadamente)
Stack maxInt = 2147483647;
Stack minInt = -2147483648;
$$ Variables para resultados
Stack resultado = 0;
SpawnPoint
PolloCrudo
$$ Operaciones aritméticas con literales enteros directos
resultado = 5 + 3; $$ 8
dropperSpider("
5
+
3
=
" bind resultado);
resultado = 10 - 7; $$ 3
dropperSpider("
10
-
7
=
" bind resultado);
resultado = 6 * 4; $$ 24
dropperSpider("
6
*
4
=
" bind resultado);
resultado = 20 // 4; $$ 5
dropperSpider("
20
4
=
" bind resultado);
resultado = 17 % 5; $$ 2
dropperSpider("
17
%
5
=
" bind resultado);
$$ Uso de literales enteros en expresiones complejas
resultado = (5 + 3) * 2 - 4 // 2; $$ 16 - 2 = 14
dropperSpider("
(
5
+
3
)
*
2
-
4
2
=
" bind resultado);
$$ Operaciones con literales enteros negativos
resultado = -5 + 10; $$ 5
dropperSpider("
-
5
+
10
=
" bind resultado);
resultado = 5 + -10; $$ -5
dropperSpider("
5
+
-
10
=
" bind resultado);
resultado = -5 * -4; $$ 20
dropperSpider("
-
5
*
-
4
=
" bind resultado);
$$ Uso de literales enteros en estructuras de control
walk i set 1 to 5 craft
PolloCrudo
dropperSpider("
Iteración
:
" bind i);
PolloAsado
$$ Comparaciones con literales enteros
target 10 > 5 craft hit
PolloCrudo
dropperSpider("
10
es
mayor
que
5
");
PolloAsado
target 0 is 0 craft hit
PolloCrudo
dropperSpider("
0
es
igual
a
0
");
PolloAsado
target -10 < -5 craft hit
PolloCrudo
dropperSpider("
-
10
es
menor
que
-
5
");
PolloAsado
$$ Operaciones con valores extremos (cuidado con overflow)
dropperSpider("
Valor
máximo
de
entero
:
" bind maxInt);
dropperSpider("
Valor
mínimo
de
entero
:
" bind minInt);
$$ Verificación del cero
target 0 is cero craft hit
PolloCrudo
dropperSpider("
Ambas
representaciones
de
cero
son
iguales
");
PolloAsado
PolloAsado
worldSave
$*
Prueba_Lit_Flotantes.ne
Propósito: Verificar reconocimiento de números flotantes (con parte decimal, sin parte decimal, negativos)
Probar: Ghast
Fecha: 28/04/2025
*$
$$ Prueba de literales flotantes en NotchEngine
$$ Verificando: flotantes con parte decimal, sin parte decimal, y negativos
WorldName PruebaLitFlotantes:
Bedrock
$$ Constantes flotantes
Obsidian Ghast CERO_PUNTO_CERO 0.0;
Obsidian Ghast PI 3.14159;
Obsidian Ghast E 2.71828;
Obsidian Ghast NEG_PI -3.14159;
Obsidian Ghast GRAVEDAD -9.8;
Inventory
$$ Flotantes positivos con parte decimal
Ghast decimal1 = 0.5;
Ghast decimal2 = 1.25;
Ghast decimal3 = 3.14159;
Ghast decimal4 = 2.71828;
Ghast decimal5 = 123.456;
$$ Flotantes negativos con parte decimal
Ghast negDecimal1 = -0.5;
Ghast negDecimal2 = -1.25;
Ghast negDecimal3 = -3.14159;
Ghast negDecimal4 = -2.71828;
Ghast negDecimal5 = -123.456;
$$ Formas alternativas (punto al principio, sin parte decimal)
Ghast decimal6 = .5; $$ Sin cero al principio, comienza con punto
Ghast decimal7 = 5.; $$ Sin decimales, termina con punto
$$ Números con muchos decimales
Ghast precisionAlta = 1.123456789012345;
$$ Números muy pequeños y muy grandes
Ghast muyPequeno = 0.0000001;
Ghast muyGrande = 1000000.0;
$$ Variables para resultados
Ghast resultado = 0.0;
SpawnPoint
PolloCrudo
$$ Operaciones aritméticas con literales flotantes directos
resultado = 5.5 :+ 3.5; $$ 9.0
dropperSpider("
5.5
:
+
3.5
=
");
dropperGhast(resultado);
resultado = 10.75 :- 7.25; $$ 3.5
dropperSpider("
10.75
:
-
7.25
=
");
dropperGhast(resultado);
resultado = 6.5 :* 2.0; $$ 13.0
dropperSpider("
6.5
:
*
2.0
=
");
dropperGhast(resultado);
resultado = 20.0 :// 4.0; $$ 5.0
dropperSpider("
20.0
:
4.0
=
");
dropperGhast(resultado);
resultado = 7.5 :% 2.0; $$ 1.5
dropperSpider("
7.5
:
%
2.0
=
");
dropperGhast(resultado);
$$ Uso de notaciones decimales alternativas
resultado = .5 :+ 2.; $$ 0.5 + 2.0 = 2.5
dropperSpider("
.
5
:
+
2
.
=
");
dropperGhast(resultado);
$$ Operaciones con literales flotantes negativos
resultado = -5.5 :+ 10.0; $$ 4.5
dropperSpider("
-
5.5
:
+
10.0
=
");
dropperGhast(resultado);
resultado = 5.0 :+ -10.0; $$ -5.0
dropperSpider("
5.0
:
+
-
10.0
=
");
dropperGhast(resultado);
resultado = -5.0 :* -4.0; $$ 20.0
dropperSpider("
-
5.0
:
*
-
4.0
=
");
dropperGhast(resultado);
$$ Expresiones complejas con flotantes
resultado = (2.5 :+ 1.5) :* 3.0 :- 5.0 :// 2.0; $$ 12.0 - 2.5 = 9.5
dropperSpider("
(
2.5
:
+
1.5
)
:
*
3.0
:
-
5.0
:
2.0
=
");
dropperGhast(resultado);
$$ Comparaciones con flotantes
target 3.14 > 3.0 craft hit
PolloCrudo
dropperSpider("
3.14
es
mayor
que
3.0
");
PolloAsado
target 0.1 :+ 0.2 isNot 0.3 craft hit $$ Debido a errores de precisión en flotantes
PolloCrudo
dropperSpider("
0.1
+
0.2
no
es
exactamente
igual
a
0.3
(
error
de
precisión
)
");
dropperGhast(0.1 :+ 0.2);
PolloAsado
$$ Conversión y coherción de tipos
Stack entero = 3.14159 >> Stack; $$ Cohersión a entero (trunca a 3)
dropperSpider("
PI
truncado
a
entero
:
" bind entero);
$$ Mostrar valores con diferentes precisiones
dropperSpider("
Valor
de
PI
:
");
dropperGhast(PI);
dropperSpider("
Número
con
alta
precisión
:
");
dropperGhast(precisionAlta);
dropperSpider("
Número
muy
pequeño
:
");
dropperGhast(muyPequeno);
dropperSpider("
Número
muy
grande
:
");
dropperGhast(muyGrande);
PolloAsado
worldSave
$*
Prueba_Lit_Caracteres.ne
Propósito: Verificar reconocimiento de caracteres (letras, dígitos, símbolos, escapes)
Probar: Rune, dropperRune, dropperSpider, dropperTorch
Fecha: 28/04/2025
*$
$$ Prueba de literales de caracteres en NotchEngine
$$ Verificando: letras, dígitos, símbolos y secuencias de escape
WorldName PruebaLitCaracteres:
Bedrock
$$ Constantes de caracteres
Obsidian Rune LETRA_A 'A';
Obsidian Rune LETRA_Z 'Z';
Obsidian Rune DIGITO_0 '0';
Obsidian Rune DIGITO_9 '9';
Obsidian Rune NUEVA_LINEA '\n';
Obsidian Rune TABULACION '\t';
Inventory
$$ Letras mayúsculas
Rune letraA = 'A';
Rune letraB = 'B';
Rune letraC = 'C';
Rune letraZ = 'Z';
$$ Letras minúsculas
Rune letraMina = 'a';
Rune letraMinb = 'b';
Rune letraMinc = 'c';
Rune letraMinz = 'z';
$$ Dígitos
Rune digito0 = '0';
Rune digito1 = '1';
Rune digito5 = '5';
Rune digito9 = '9';
$$ Símbolos comunes
Rune simboloExclamacion = '!';
Rune simboloInterrogacion = '?';
Rune simboloArroba = '@';
Rune simboloNumeral = '#';
Rune simboloDolar = '$';
Rune simboloPorcentaje = '%';
Rune simboloAmpersand = '&';
Rune simboloAsterisco = '*';
Rune simboloParentesisIzq = '(';
Rune simboloParentesisDer = ')';
Rune simboloGuion = '-';
Rune simboloGuionBajo = '_';
Rune simboloIgual = '=';
Rune simboloMas = '+';
Rune simboloCorcheteIzq = '[';
Rune simboloCorcheteDer = ']';
Rune simboloLlaveIzq = '{';
Rune simboloLlaveDer = '}';
Rune simboloPuntoyComa = ';';
Rune simboloDosPuntos = ':';
Rune simboloComillaSimple = '\'';
Rune simboloComillaDoble = '"
';
Rune simboloBarra = '
';
Rune simboloBarraInversa = '
';
Rune simboloBarraVertical = '
';
Rune simboloComa = '
,
';
Rune simboloPunto = '
.
';
Rune simboloMenorQue = '
<
';
Rune simboloMayorQue = '
>
';
$$ Secuencias de escape
Rune escapeNuevaLinea = '
n
';
Rune escapeTabulacion = '
t
';
Rune escapeRetornoCarro = '
r
';
Rune escapeBarraInversa = '
';
Rune escapeComillaSimple = '
''
;
Rune
escapeComillaDoble
=
'\"'
;
SpawnPoint
PolloCrudo
dropperSpider
(
"Letras mayúsculas: "
)
;
dropperRune
(
letraA
)
;
dropperRune
(
letraB
)
;
dropperRune
(
letraC
)
;
dropperSpider
(
"Letras minúsculas: "
)
;
dropperRune
(
letraMina
)
;
dropperRune
(
letraMinb
)
;
dropperRune
(
letraMinc
)
;
dropperSpider
(
"Dígitos: "
)
;
dropperRune
(
digito0
)
;
dropperRune
(
digito1
)
;
dropperRune
(
digito5
)
;
dropperRune
(
digito9
)
;
dropperSpider
(
"Símbolos: "
)
;
dropperRune
(
simboloExclamacion
)
;
dropperRune
(
simboloInterrogacion
)
;
dropperRune
(
simboloArroba
)
;
dropperRune
(
simboloNumeral
)
;
Spider
texto
=
"NotchEngine"
;
Rune
primerCaracter
=
texto
[
0
]
;
Rune
ultimoCaracter
=
texto
[
10
]
;
dropperSpider
(
"Primer carácter de 'NotchEngine': "
)
;
dropperRune
(
primerCaracter
)
;
dropperSpider
(
"Último carácter de 'NotchEngine': "
)
;
dropperRune
(
ultimoCaracter
)
;
Rune
letraMinuscula
=
'a'
;
Rune
letraMayuscula
=
etchUp
(
letraMinuscula
)
;
dropperSpider
(
"Minúscula: "
)
;
dropperRune
(
letraMinuscula
)
;
dropperSpider
(
"Convertida a mayúscula: "
)
;
dropperRune
(
letraMayuscula
)
;
letraMinuscula
=
etchDown
(
letraMayuscula
)
;
dropperSpider
(
"Convertida nuevamente a minúscula: "
)
;
dropperRune
(
letraMinuscula
)
;
Torch
esLetra
=
isEngraved
(
'A'
)
;
Torch
esDigito
=
isInscribed
(
'5'
)
;
dropperSpider
(
"¿'A' es una letra? "
)
;
dropperTorch
(
esLetra
)
;
dropperSpider
(
"¿'5' es un dígito? "
)
;
dropperTorch
(
esDigito
)
;
esLetra
=
isEngraved
(
'7'
)
;
esDigito
=
isInscribed
(
'K'
)
;
dropperSpider
(
"¿'7' es una letra? "
)
;
dropperTorch
(
esLetra
)
;
dropperSpider
(
"¿'K' es un dígito? "
)
;
dropperTorch
(
esDigito
)
;
Stack
valorAsciiA
=
letraA
>
>
Stack
;
dropperSpider
(
"Valor ASCII de 'A': "
bind
valorAsciiA
)
;
PolloAsado
worldSave
WorldName
PruebaLitStrings
:
Bedrock
Obsidian
Spider
VACIO
""
;
Obsidian
Spider
ESPACIO
" "
;
Obsidian
Spider
SALUDO
"Hola Mundo"
;
Obsidian
Spider
CON_COMILLAS
"Este string tiene \"comillas\""
;
Obsidian
Spider
MULTILINEA
"Primera línea\nSegunda línea"
;
Inventory
Spider
cadenaVacia
=
""
;
Spider
espacioSimple
=
" "
;
Spider
cadenaSimple
=
"Texto simple"
;
Spider
conNumeros
=
"Notch Engine v1.0"
;
Spider
conSimbolos
=
"¡Hola, mundo! ¿Cómo estás?"
;
Spider
conCaracteresEspeciales
=
"#$%&/()=?¡"
;
Spider
conNuevaLinea
=
"Primera línea\nSegunda línea"
;
Spider
conTabulacion
=
"Columna1\tColumna2\tColumna3"
;
Spider
conRetornoCarro
=
"Texto con\rretorno de carro"
;
Spider
conBarraInversa
=
"Ruta de archivo: C:\\Archivos\\datos.txt"
;
Spider
conComillasSimples
=
"Texto con 'comillas simples'"
;
Spider
conComillasDobles
=
"Texto con \"comillas dobles\""
;
Spider
mixto
=
"Abc123!@#\n\t\"'"
;
Spider
cadenaLarga
=
"Esta es una cadena de texto más larga que contiene múltiples palabras, números como 12345, y símbolos como $%&. Es útil para probar el manejo de cadenas extensas en el analizador léxico y asegurarse de que no hay limitaciones inesperadas en la longitud de las cadenas."
;
Spider
prefijo
=
"Notch"
;
Spider
sufijo
=
"Engine"
;
Spider
resultado
;
SpawnPoint
PolloCrudo
dropperSpider
(
"Cadena simple: "
bind
cadenaSimple
)
;
dropperSpider
(
"Cadena con números: "
bind
conNumeros
)
;
dropperSpider
(
"Cadena con símbolos: "
bind
conSimbolos
)
;
resultado
=
bind
(
prefijo
,
" "
bind
sufijo
)
;
dropperSpider
(
"Concatenación: "
bind
resultado
)
;
Stack
longitud
=
#
(
resultado
)
;
dropperSpider
(
"Longitud de '"
bind
resultado
bind
"': "
bind
longitud
)
;
Spider
subcadena
=
from
resultado
#
#
0
#
#
5
;
dropperSpider
(
"Subcadena (0, 5): "
bind
subcadena
)
;
Spider
sinNotch
=
except
resultado
#
#
0
#
#
6
;
dropperSpider
(
"Sin los primeros 6 caracteres: "
bind
sinNotch
)
;
Stack
posicion
=
seek
(
resultado
,
"Engine"
)
;
dropperSpider
(
"Posición de 'Engine': "
bind
posicion
)
;
Rune
primerCaracter
=
resultado
[
0
]
;
dropperSpider
(
"Primer carácter: "
)
;
dropperRune
(
primerCaracter
)
;
Rune
ultimoCaracter
=
resultado
[
11
]
;
dropperSpider
(
"Último carácter: "
)
;
dropperRune
(
ultimoCaracter
)
;
dropperSpider
(
"Cadena con nueva línea:"
)
;
dropperSpider
(
conNuevaLinea
)
;
dropperSpider
(
"Cadena con tabulaciones:"
)
;
dropperSpider
(
conTabulacion
)
;
dropperSpider
(
"Cadena con comillas dobles:"
)
;
dropperSpider
(
conComillasDobles
)
;
dropperSpider
(
"Cadena larga:"
)
;
dropperSpider
(
cadenaLarga
)
;
target
cadenaVacia
is
""
craft
hit
PolloCrudo
dropperSpider
(
"La cadena está vacía"
)
;
PolloAsado
target
SALUDO
is
"Hola Mundo"
craft
hit
PolloCrudo
dropperSpider
(
"Las cadenas son iguales"
)
;
PolloAsado
PolloAsado
worldSave
WorldName
PruebaLitArreglos
:
Bedrock
Inventory
Shelf
[
5
]
Stack
numerosSimples
=
[
1
,
2
,
3
,
4
,
5
]
;
Shelf
[
3
]
Stack
numerosNegativos
=
[
-
10
,
-
20
,
-
30
]
;
Shelf
[
4
]
Stack
numerosMixtos
=
[
-
2
,
0
,
2
,
4
]
;
Shelf
[
1
]
Stack
unicoElemento
=
[
42
]
;
Shelf
[
0
]
Stack
arregloVacio
=
[
]
;
Shelf
[
5
]
Rune
vocales
=
[
'a'
,
'e'
,
'i'
,
'o'
,
'u'
]
;
Shelf
[
5
]
Rune
simbolos
=
[
'!'
,
'@'
,
'#'
,
'$'
,
'%'
]
;
Shelf
[
3
]
Spider
nombres
=
[
"Steve"
,
"Alex"
,
"Herobrine"
]
;
Shelf
[
4
]
Spider
diasSemana
=
[
"Lunes"
,
"Martes"
,
"Miércoles"
,
"Jueves"
]
;
Shelf
[
4
]
Torch
flags
=
[
On
,
Off
,
On
,
On
]
;
Shelf
[
3
]
Ghast
decimales
=
[
3.14
,
2.71
,
1.618
]
;
Shelf
[
3
]
Shelf
[
3
]
Stack
matriz
=
[
[
1
,
2
,
3
]
,
[
4
,
5
,
6
]
,
[
7
,
8
,
9
]
]
;
Shelf
[
2
]
Shelf
[
2
]
Shelf
[
2
]
Stack
cubo
=
[
[
[
1
,
2
]
,
[
3
,
4
]
]
,
[
[
5
,
6
]
,
[
7
,
8
]
]
]
;
Stack
suma
=
0
;
Stack
elementoActual
=
0
;
SpawnPoint
PolloCrudo
elementoActual
=
numerosSimples
[
0
]
;
dropperSpider
(
"Primer elemento del arreglo: "
bind
elementoActual
)
;
elementoActual
=
numerosSimples
[
4
]
;
dropperSpider
(
"Último elemento del arreglo: "
bind
elementoActual
)
;
numerosSimples
[
2
]
=
30
;
dropperSpider
(
"Elemento modificado: "
bind
numerosSimples
[
2
]
)
;
suma
=
0
;
walk
i
set
0
to
4
craft
PolloCrudo
suma
+
=
numerosSimples
[
i
]
;
dropperSpider
(
"Elemento "
bind
i
bind
": "
bind
numerosSimples
[
i
]
)
;
PolloAsado
dropperSpider
(
"Suma de todos los elementos: "
bind
suma
)
;
dropperSpider
(
"Vocales: "
)
;
walk
i
set
0
to
4
craft
PolloCrudo
dropperRune
(
vocales
[
i
]
)
;
PolloAsado
dropperSpider
(
"Nombres: "
)
;
walk
i
set
0
to
2
craft
PolloCrudo
dropperSpider
(
nombres
[
i
]
)
;
PolloAsado
dropperSpider
(
"Flags: "
)
;
walk
i
set
0
to
3
craft
PolloCrudo
dropperTorch
(
flags
[
i
]
)
;
PolloAsado
dropperSpider
(
"Decimales: "
)
;
walk
i
set
0
to
2
craft
PolloCrudo
dropperGhast
(
decimales
[
i
]
)
;
PolloAsado
elementoActual
=
matriz
[
1
]
[
1
]
;
dropperSpider
(
"Elemento central de la matriz: "
bind
elementoActual
)
;
matriz
[
0
]
[
2
]
=
10
;
dropperSpider
(
"Elemento modificado de la matriz: "
bind
matriz
[
0
]
[
2
]
)
;
dropperSpider
(
"Matriz completa:"
)
;
walk
i
set
0
to
2
craft
PolloCrudo
walk
j
set
0
to
2
craft
PolloCrudo
dropperStack
(
matriz
[
i
]
[
j
]
)
;
PolloAsado
dropperSpider
(
""
)
;
PolloAsado
elementoActual
=
cubo
[
1
]
[
0
]
[
1
]
;
dropperSpider
(
"Elemento de cubo [1][0][1]: "
bind
elementoActual
)
;
Shelf
[
4
]
Stack
fibonacci
=
[
1
,
1
,
2
,
3
]
;
dropperSpider
(
"Fibonacci: "
)
;
walk
i
set
0
to
3
craft
PolloCrudo
dropperStack
(
fibonacci
[
i
]
)
;
PolloAsado
PolloAsado
worldSave
WorldName
PruebaLitRegistros
:
Inventory
Entity
Jugador
PolloCrudo
Spider
nombre
;
Stack
nivel
;
Ghast
salud
;
Torch
activo
;
PolloAsado
;
Entity
Coordenada
PolloCrudo
Stack
x
;
Stack
y
;
Stack
z
;
PolloAsado
;
Entity
Configuracion
PolloCrudo
Torch
modoDebug
;
Stack
volumen
;
Spider
idioma
;
PolloAsado
;
Entity
Jugador
steve
=
{
nombre
:
"Steve"
,
nivel
:
1
,
salud
:
20.0
,
activo
:
On
}
;
Entity
Jugador
alex
=
{
nombre
:
"Alex"
,
nivel
:
2
,
salud
:
18.5
,
activo
:
On
}
;
Entity
Coordenada
posicion
=
{
x
:
10
,
y
:
20
,
z
:
30
}
;
Entity
Configuracion
config
=
{
modoDebug
:
Off
,
volumen
:
75
,
idioma
:
"Español"
}
;
Entity
Jugador
jugadorVacio
=
{
}
;
Entity
Coordenada
origen
=
{
x
:
0
}
;
Entity
Coordenada
punto
=
{
x
:
5
+
5
,
y
:
10
*
2
,
z
:
100
2
}
;
SpawnPoint
PolloCrudo
dropperSpider
(
steve
@
nombre
)
;
dropperStack
(
posicion
@
x
)
;
dropperTorch
(
config
@
modoDebug
)
;
steve
@
nivel
=
5
;
posicion
@
z
=
50
;
Stack
nivelTotal
=
steve
@
nivel
+
alex
@
nivel
;
dropperStack
(
nivelTotal
)
;
wither
steve
craft
PolloCrudo
dropperSpider
(
"Nombre: "
bind
nombre
)
;
dropperStack
(
nivel
)
;
dropperGhast
(
salud
)
;
PolloAsado
Entity
Jugador
herobrine
=
{
nombre
:
"Herobrine"
,
nivel
:
100
,
salud
:
1000.0
,
activo
:
On
}
;
Entity
Coordenada
pos2
=
{
x
:
100
,
y
:
200
,
z
:
300
}
;
PolloAsado
worldSave
WorldName
PruebaLitConjuntos
:
Inventory
Chest
numeros
=
{
:
1
,
2
,
3
,
4
,
5
:
}
;
Chest
primos
=
{
:
2
,
3
,
5
,
7
,
11
,
13
,
17
,
19
:
}
;
Chest
pares
=
{
:
2
,
4
,
6
,
8
,
10
:
}
;
Chest
vocales
=
{
:
'a'
,
'e'
,
'i'
,
'o'
,
'u'
:
}
;
Chest
consonantes
=
{
:
'b'
,
'c'
,
'd'
,
'f'
,
'g'
:
}
;
Chest
nombres
=
{
:
"Steve"
,
"Alex"
,
"Herobrine"
,
"Notch"
:
}
;
Chest
herramientas
=
{
:
"Espada"
,
"Pico"
,
"Hacha"
,
"Pala"
:
}
;
Chest
vacio
=
{
:
:
}
;
Chest
singleton
=
{
:
42
:
}
;
Chest
mezcla
=
{
:
1
,
'a'
,
"texto"
:
}
;
Chest
calculados
=
{
:
1
+
1
,
2
*
2
,
10
2
:
}
;
Chest
booleanos
=
{
:
On
,
Off
:
}
;
SpawnPoint
PolloCrudo
add
(
numeros
,
6
)
;
dropperSpider
(
"Después de add(numeros, 6):"
)
;
drop
(
primos
,
2
)
;
dropperSpider
(
"Después de drop(primos, 2):"
)
;
Chest
union
=
feed
(
numeros
,
primos
)
;
dropperSpider
(
"Unión de numeros y primos:"
)
;
Chest
interseccion
=
map
(
numeros
,
pares
)
;
dropperSpider
(
"Intersección de numeros y pares:"
)
;
Torch
contiene
=
biom
(
vocales
,
'a'
)
;
dropperTorch
(
contiene
)
;
Torch
esVacio
=
void
(
vacio
)
;
dropperTorch
(
esVacio
)
;
Chest
conEspacios
=
{
:
'a'
,
'b'
,
'c'
:
}
;
Chest
conComentarios
=
{
:
1
,
2
,
3
:
}
;
Chest
{
:
1
,
'x'
,
"y"
:
}
;
PolloAsado
worldSave
WorldName
PruebaLitArchivos
:
Inventory
Book
archivoConfiguracion
=
{
"config.txt"
,
'L'
}
;
Book
archivoJugadores
=
{
"jugadores.dat"
,
'L'
}
;
Book
archivoNiveles
=
{
"niveles/nivel1.map"
,
'L'
}
;
Book
archivoLog
=
{
"sistema.log"
,
'E'
}
;
Book
archivoResultados
=
{
"resultados.txt"
,
'E'
}
;
Book
archivoExportacion
=
{
"export/datos.csv"
,
'E'
}
;
Book
archivoPuntajes
=
{
"puntajes.dat"
,
'A'
}
;
Book
archivoInventario
=
{
"inventario.sav"
,
'A'
}
;
Book
archivoEspecial
=
{
"archivo con espacios.txt"
,
'L'
}
;
Book
archivoEspecial2
=
{
"datos_especiales-2023.dat"
,
'E'
}
;
Book
archivoRutaRelativa
=
{
"../datos/config.ini"
,
'L'
}
;
Book
archivoRutaAbsoluta
=
{
"C:/Notch/Engine/data.bin"
,
'E'
}
;
Book
archivoTexto
=
{
"readme.txt"
,
'L'
}
;
Book
archivoImagen
=
{
"textura.png"
,
'L'
}
;
Book
archivoJSON
=
{
"settings.json"
,
'A'
}
;
Book
archivoXML
=
{
"estructura.xml"
,
'A'
}
;
Book
conBarras
=
{
"dir/subdir/archivo.ext"
,
'L'
}
;
Book
conPuntos
=
{
"../../archivo.ext"
,
'E'
}
;
Book
espaciado1
=
{
"compacto.txt"
,
'L'
}
;
Book
espaciado2
=
{
"espacios.txt"
,
'E'
}
;
Book
comentado
=
{
"log.txt"
,
'L'
}
;
SpawnPoint
PolloCrudo
unlock
(
archivoLog
)
;
forge
(
archivoLog
,
"Entrada de log: Inicio de programa"
)
;
lock
(
archivoLog
)
;
Book
nuevoArchivo
=
make
(
{
"nuevo.txt"
,
'E'
}
)
;
unlock
(
archivoConfiguracion
)
;
Spider
contenido
=
gather
(
archivoConfiguracion
)
;
lock
(
archivoConfiguracion
)
;
expand
(
archivoLog
,
archivoResultados
)
;
Book
{
"sinVariable.txt"
,
'A'
}
;
Book
arch1
=
{
"uno.txt"
,
'L'
}
;
Book
arch2
=
{
"dos.txt"
,
'E'
}
;
Book
conComentarioMedio
=
{
"comentado.txt"
,
'A'
}
;
PolloAsado
worldSave
WorldName
PruebaOpAritmeticos
:
Inventory
Stack
a
=
10
;
Stack
b
=
3
;
Stack
c
;
Stack
resultado
;
SpawnPoint
PolloCrudo
c
=
a
+
b
;
dropperSpider
(
"Suma: "
bind
c
)
;
c
=
a
-
b
;
dropperSpider
(
"Resta: "
bind
c
)
;
c
=
a
*
b
;
dropperSpider
(
"Multiplicación: "
bind
c
)
;
c
=
a
b
;
dropperSpider
(
"División entera: "
bind
c
)
;
c
=
a
%
b
;
dropperSpider
(
"Módulo: "
bind
c
)
;
resultado
=
a
+
b
*
c
;
dropperSpider
(
"a + b * c = "
bind
resultado
)
;
resultado
=
(
a
+
b
)
*
c
;
dropperSpider
(
"(a + b) * c = "
bind
resultado
)
;
resultado
=
a
+
b
+
c
;
dropperSpider
(
"a + b + c = "
bind
resultado
)
;
resultado
=
a
*
b
c
+
a
-
b
;
dropperSpider
(
"a * b // c + a - b = "
bind
resultado
)
;
resultado
=
-
a
;
dropperSpider
(
"-a = "
bind
resultado
)
;
resultado
=
5
+
3
;
dropperSpider
(
"5 + 3 = "
bind
resultado
)
;
resultado
=
-
(
a
+
b
)
;
dropperSpider
(
"-(a + b) = "
bind
resultado
)
;
resultado
=
a
+
b
;
resultado
=
a
-
b
;
resultado
=
a
*
b
;
resultado
=
a
b
;
resultado
=
a
%
b
;
resultado
=
a
+
b
;
resultado
=
a
-
b
;
resultado
=
a
*
b
;
resultado
=
a
b
;
resultado
=
a
%
b
;
resultado
=
a
+
b
;
resultado
=
a
*
b
;
resultado
=
(
(
(
(
a
+
b
)
*
c
)
2
)
%
10
)
;
soulsand
a
;
resultado
=
a
+
b
;
magma
b
;
resultado
=
a
-
b
;
PolloAsado
worldSave
WorldName
PruebaOpFlotantes
:
Inventory
Ghast
x
=
10.5
;
Ghast
y
=
3.25
;
Ghast
z
;
Ghast
resultado
;
SpawnPoint
PolloCrudo
z
=
x
:
+
y
;
dropperSpider
(
"Suma flotante: "
bind
z
)
;
z
=
x
:
-
y
;
dropperSpider
(
"Resta flotante: "
bind
z
)
;
z
=
x
:
*
y
;
dropperSpider
(
"Multiplicación flotante: "
bind
z
)
;
z
=
x
:
y
;
dropperSpider
(
"División flotante: "
bind
z
)
;
z
=
x
:
%
y
;
dropperSpider
(
"Módulo flotante: "
bind
z
)
;
resultado
=
x
:
+
y
:
*
z
;
dropperSpider
(
"x :+ y :* z = "
bind
resultado
)
;
resultado
=
(
x
:
+
y
)
:
*
z
;
dropperSpider
(
"(x :+ y) :* z = "
bind
resultado
)
;
resultado
=
x
:
+
y
:
+
z
;
dropperSpider
(
"x :+ y :+ z = "
bind
resultado
)
;
resultado
=
x
:
*
y
:
z
:
+
x
:
-
y
;
dropperSpider
(
"x :* y :// z :+ x :- y = "
bind
resultado
)
;
resultado
=
-
x
;
dropperSpider
(
"-x = "
bind
resultado
)
;
resultado
=
5.5
:
+
3.2
;
dropperSpider
(
"5.5 :+ 3.2 = "
bind
resultado
)
;
resultado
=
-
(
x
:
+
y
)
;
dropperSpider
(
"-(x :+ y) = "
bind
resultado
)
;
resultado
=
x
:
+
y
;
resultado
=
x
:
-
y
;
resultado
=
x
:
*
y
;
resultado
=
x
:
y
;
resultado
=
x
:
%
y
;
resultado
=
x
:
+
y
;
resultado
=
x
:
-
y
;
resultado
=
x
:
*
y
;
resultado
=
x
:
y
;
resultado
=
x
:
%
y
;
resultado
=
x
:
+
y
;
resultado
=
x
:
*
y
;
resultado
=
(
(
(
(
x
:
+
y
)
:
*
z
)
:
2.0
)
:
%
10.0
)
;
Ghast
mezcla1
=
x
:
+
5
;
Ghast
mezcla2
=
3.5
:
*
y
;
Ghast
mezcla3
=
x
:
+
(
y
:
*
2.0
)
:
1.5
;
Spider
texto
=
"Notch:Engine"
;
Stack
entero
=
(
x
:
+
y
)
>
>
Stack
;
PolloAsado
worldSave
WorldName
PruebaOpComparacion
:
Inventory
Stack
a
=
10
;
Stack
b
=
5
;
Torch
resultado
;
Ghast
x
=
3.5
;
Ghast
y
=
2.75
;
Spider
cadena1
=
"abc"
;
Spider
cadena2
=
"def"
;
Rune
char1
=
'A'
;
Rune
char2
=
'B'
;
Torch
bool1
=
On
;
Torch
bool2
=
Off
;
SpawnPoint
PolloCrudo
resultado
=
a
<
b
;
dropperSpider
(
"a < b: "
bind
resultado
)
;
resultado
=
x
<
y
;
dropperSpider
(
"x < y: "
bind
resultado
)
;
resultado
=
cadena1
<
cadena2
;
dropperSpider
(
"cadena1 < cadena2: "
bind
resultado
)
;
resultado
=
char1
<
char2
;
dropperSpider
(
"char1 < char2: "
bind
resultado
)
;
resultado
=
a
>
b
;
dropperSpider
(
"a > b: "
bind
resultado
)
;
resultado
=
x
>
y
;
dropperSpider
(
"x > y: "
bind
resultado
)
;
resultado
=
a
<=
b
;
dropperSpider
(
"a <= b: "
bind
resultado
)
;
resultado
=
x
<=
y
;
dropperSpider
(
"x <= y: "
bind
resultado
)
;
resultado
=
a
>=
b
;
dropperSpider
(
"a >= b: "
bind
resultado
)
;
resultado
=
x
>=
y
;
dropperSpider
(
"x >= y: "
bind
resultado
)
;
resultado
=
a
is
b
;
dropperSpider
(
"a is b: "
bind
resultado
)
;
resultado
=
x
is
y
;
dropperSpider
(
"x is y: "
bind
resultado
)
;
resultado
=
cadena1
is
cadena2
;
dropperSpider
(
"cadena1 is cadena2: "
bind
resultado
)
;
resultado
=
bool1
is
bool2
;
dropperSpider
(
"bool1 is bool2: "
bind
resultado
)
;
resultado
=
a
isNot
b
;
dropperSpider
(
"a isNot b: "
bind
resultado
)
;
resultado
=
x
isNot
y
;
dropperSpider
(
"x isNot y: "
bind
resultado
)
;
resultado
=
cadena1
isNot
cadena2
;
dropperSpider
(
"cadena1 isNot cadena2: "
bind
resultado
)
;
resultado
=
bool1
isNot
bool2
;
dropperSpider
(
"bool1 isNot bool2: "
bind
resultado
)
;
resultado
=
a
<
b
;
resultado
=
a
>
b
;
resultado
=
a
<=
b
;
resultado
=
a
>=
b
;
resultado
=
aisb
;
resultado
=
a
is
b
;
resultado
=
aisNotb
;
resultado
=
a
isNot
b
;
resultado
=
a
<
b
;
resultado
=
a
>
b
;
resultado
=
a
<=
b
;
resultado
=
a
>=
b
;
resultado
=
a
is
b
;
resultado
=
a
isNot
b
;
target
a
<
b
craft
hit
PolloCrudo
dropperSpider
(
"a es menor que b"
)
;
PolloAsado
repeater
x
>
y
craft
PolloCrudo
dropperSpider
(
"x es mayor que y"
)
;
PolloAsado
resultado
=
(
a
+
b
)
>
(
x
:
+
y
)
;
resultado
=
a
*
2
<=
b
*
3
;
resultado
=
(
a
2
)
is
(
b
1
)
;
resultado
=
bind
(
cadena1
,
cadena2
)
isNot
"abcdef"
;
Spider
islandia
=
"país"
;
Stack
isNotacion
=
42
;
PolloAsado
worldSave
WorldName
PruebaOpAsignacion
:
Inventory
Stack
contador
=
10
;
Stack
acumulador
=
0
;
Ghast
decimal
=
5.5
;
Spider
texto
=
"Notch"
;
Shelf
[
5
]
Stack
arreglo
;
Entity
Punto
PolloCrudo
Stack
x
;
Stack
y
;
PolloAsado
;
Entity
Punto
punto
;
SpawnPoint
PolloCrudo
contador
=
5
;
dropperSpider
(
"Asignación simple: "
bind
contador
)
;
decimal
=
3.14
;
texto
=
"Engine"
;
contador
+
=
3
;
dropperSpider
(
"Asignación con suma: "
bind
contador
)
;
acumulador
=
0
;
acumulador
+
=
contador
;
acumulador
+
=
2
;
dropperSpider
(
"Acumulador después de += : "
bind
acumulador
)
;
contador
-
=
2
;
dropperSpider
(
"Asignación con resta: "
bind
contador
)
;
acumulador
=
20
;
acumulador
-
=
5
;
acumulador
-
=
contador
;
dropperSpider
(
"Acumulador después de -= : "
bind
acumulador
)
;
contador
*
=
3
;
dropperSpider
(
"Asignación con multiplicación: "
bind
contador
)
;
acumulador
=
2
;
acumulador
*
=
contador
;
dropperSpider
(
"Acumulador después de *= : "
bind
acumulador
)
;
contador
=
2
;
dropperSpider
(
"Asignación con división: "
bind
contador
)
;
acumulador
=
50
;
acumulador
=
5
;
dropperSpider
(
"Acumulador después de /= : "
bind
acumulador
)
;
contador
%
=
3
;
dropperSpider
(
"Asignación con módulo: "
bind
contador
)
;
acumulador
=
17
;
acumulador
%
=
5
;
dropperSpider
(
"Acumulador después de %= : "
bind
acumulador
)
;
arreglo
[
0
]
=
10
;
arreglo
[
1
]
=
20
;
arreglo
[
2
]
=
30
;
arreglo
[
0
]
+
=
5
;
dropperSpider
(
"arreglo[0] después de += : "
bind
arreglo
[
0
]
)
;
arreglo
[
1
]
-
=
5
;
dropperSpider
(
"arreglo[1] después de -= : "
bind
arreglo
[
1
]
)
;
arreglo
[
2
]
*
=
2
;
dropperSpider
(
"arreglo[2] después de *= : "
bind
arreglo
[
2
]
)
;
punto
@
x
=
10
;
punto
@
y
=
20
;
punto
@
x
+
=
5
;
dropperSpider
(
"punto@x después de += : "
bind
punto
@
x
)
;
punto
@
y
-
=
8
;
dropperSpider
(
"punto@y después de -= : "
bind
punto
@
y
)
;
contador
=
5
;
contador
+
=
3
;
contador
-
=
2
;
contador
*
=
4
;
contador
=
2
;
contador
%
=
3
;
contador
=
5
;
contador
+
=
3
;
contador
-
=
2
;
contador
*
=
4
;
contador
=
2
;
contador
%
=
3
;
contador
=
10
;
contador
+
=
5
;
Stack
a
=
1
,
b
=
2
,
c
=
3
;
contador
=
(
a
+
b
)
*
c
;
contador
+
=
a
*
b
;
contador
-
=
a
+
b
;
contador
*
=
(
a
*
2
)
+
(
b
*
3
)
;
contador
=
a
+
1
;
contador
%
=
b
*
2
;
a
=
10
;
b
=
20
;
c
=
30
;
Spider
igual_texto
=
"Este texto tiene un signo = dentro"
;
Spider
mas_texto
=
"Este texto tiene un signo + dentro"
;
Spider
menos_texto
=
"Este texto tiene un signo - dentro"
;
Spider
por_texto
=
"Este texto tiene un signo * dentro"
;
Spider
div_texto
=
"Este texto tiene un signo / dentro"
;
Spider
mod_texto
=
"Este texto tiene un signo % dentro"
;
PolloAsado
worldSave
WorldName
PruebaOpAcceso
:
Inventory
Shelf
[
5
]
Stack
numeros
;
Shelf
[
3
]
Shelf
[
3
]
matriz
;
Shelf
[
2
]
Shelf
[
2
]
Shelf
[
2
]
cubo
;
Spider
texto
=
"Notch Engine"
;
Entity
Punto
PolloCrudo
Stack
x
;
Stack
y
;
Stack
z
;
PolloAsado
;
Entity
Punto
punto
;
Entity
Persona
PolloCrudo
Spider
nombre
;
Stack
edad
;
Torch
activo
;
Shelf
[
3
]
Stack
notas
;
PolloAsado
;
Entity
Persona
estudiante
;
Shelf
[
3
]
Entity
Punto
puntos
;
Entity
Contenedor
PolloCrudo
Shelf
[
5
]
Stack
valores
;
Spider
etiqueta
;
PolloAsado
;
Entity
Contenedor
caja
;
SpawnPoint
PolloCrudo
numeros
[
0
]
=
10
;
numeros
[
1
]
=
20
;
numeros
[
2
]
=
30
;
Stack
valor
=
numeros
[
0
]
;
dropperSpider
(
"Valor en numeros[0]: "
bind
valor
)
;
Stack
indice
=
2
;
valor
=
numeros
[
indice
]
;
dropperSpider
(
"Valor en numeros[indice]: "
bind
valor
)
;
valor
=
numeros
[
1
+
1
]
;
dropperSpider
(
"Valor en numeros[1 + 1]: "
bind
valor
)
;
matriz
[
0
]
[
0
]
=
11
;
matriz
[
0
]
[
1
]
=
12
;
matriz
[
1
]
[
0
]
=
21
;
matriz
[
1
]
[
1
]
=
22
;
valor
=
matriz
[
1
]
[
1
]
;
dropperSpider
(
"Valor en matriz[1][1]: "
bind
valor
)
;
valor
=
matriz
[
indice
-
1
]
[
indice
-
1
]
;
dropperSpider
(
"Valor en matriz[indice - 1][indice - 1]: "
bind
valor
)
;
cubo
[
0
]
[
0
]
[
0
]
=
111
;
cubo
[
1
]
[
1
]
[
1
]
=
222
;
valor
=
cubo
[
1
]
[
1
]
[
1
]
;
dropperSpider
(
"Valor en cubo[1][1][1]: "
bind
valor
)
;
Rune
caracter
=
texto
[
0
]
;
dropperSpider
(
"Carácter en texto[0]: "
bind
caracter
)
;
caracter
=
texto
[
6
]
;
dropperSpider
(
"Carácter en texto[6]: "
bind
caracter
)
;
caracter
=
texto
[
indice
*
2
]
;
dropperSpider
(
"Carácter en texto[indice * 2]: "
bind
caracter
)
;
texto
[
0
]
=
'n'
;
dropperSpider
(
"Texto modificado: "
bind
texto
)
;
punto
@
x
=
10
;
punto
@
y
=
20
;
punto
@
z
=
30
;
valor
=
punto
@
x
;
dropperSpider
(
"Valor en punto@x: "
bind
valor
)
;
punto
@
y
=
punto
@
x
*
2
;
dropperSpider
(
"Valor en punto@y después de asignación: "
bind
punto
@
y
)
;
estudiante
@
nombre
=
"Steve"
;
estudiante
@
edad
=
25
;
estudiante
@
activo
=
On
;
estudiante
@
notas
[
0
]
=
85
;
estudiante
@
notas
[
1
]
=
90
;
estudiante
@
notas
[
2
]
=
95
;
Spider
nombre
=
estudiante
@
nombre
;
dropperSpider
(
"Nombre del estudiante: "
bind
nombre
)
;
Stack
nota
=
estudiante
@
notas
[
1
]
;
dropperSpider
(
"Segunda nota del estudiante: "
bind
nota
)
;
puntos
[
0
]
@
x
=
1
;
puntos
[
0
]
@
y
=
2
;
puntos
[
0
]
@
z
=
3
;
puntos
[
1
]
@
x
=
4
;
puntos
[
1
]
@
y
=
5
;
puntos
[
1
]
@
z
=
6
;
valor
=
puntos
[
1
]
@
y
;
dropperSpider
(
"Valor en puntos[1]@y: "
bind
valor
)
;
caja
@
etiqueta
=
"Items"
;
caja
@
valores
[
0
]
=
100
;
caja
@
valores
[
1
]
=
200
;
valor
=
caja
@
valores
[
1
]
;
dropperSpider
(
"Valor en caja@valores[1]: "
bind
valor
)
;
valor
=
numeros
[
0
]
;
nombre
=
estudiante
@
nombre
;
valor
=
numeros
[
0
]
;
valor
=
matriz
[
1
]
[
1
]
;
nombre
=
estudiante
@
nombre
;
valor
=
cubo
[
0
]
[
matriz
[
0
]
[
0
]
%
3
]
[
numeros
[
0
]
10
]
;
valor
=
numeros
[
0
]
;
nombre
=
estudiante
@
nombre
;
Spider
textoCuadrado
=
"Esto no es un [acceso]"
;
Spider
textoArroba
=
"Email: usuario@dominio.com"
;
PolloAsado
worldSave
WorldName
PruebaOpEspeciales
:
Bedrock
Obsidian
Stack
MAX_SIZE
1024
;
Inventory
Stack
entero
=
42
;
Ghast
flotante
=
3.14159
;
Spider
texto
=
"Notch Engine"
;
Rune
caracter
=
'A'
;
Torch
booleano
=
On
;
Shelf
[
5
]
Stack
arreglo
;
Chest
conjunto
=
{
:
1
,
2
,
3
:
}
;
Entity
Punto
PolloCrudo
Stack
x
;
Stack
y
;
PolloAsado
;
Entity
Punto
punto
;
SpawnPoint
PolloCrudo
Stack
tamanoStack
=
chunk
Stack
;
Stack
tamanoGhast
=
chunk
Ghast
;
Stack
tamanoSpider
=
chunk
Spider
;
Stack
tamanoRune
=
chunk
Rune
;
Stack
tamanoTorch
=
chunk
Torch
;
dropperSpider
(
"Tamaño de Stack en bytes: "
bind
tamanoStack
)
;
dropperSpider
(
"Tamaño de Ghast en bytes: "
bind
tamanoGhast
)
;
dropperSpider
(
"Tamaño de Spider en bytes: "
bind
tamanoSpider
)
;
dropperSpider
(
"Tamaño de Rune en bytes: "
bind
tamanoRune
)
;
dropperSpider
(
"Tamaño de Torch en bytes: "
bind
tamanoTorch
)
;
Stack
tamanoShelf
=
chunk
Shelf
[
5
]
Stack
;
Stack
tamanoChest
=
chunk
Chest
;
Stack
tamanoPunto
=
chunk
Punto
;
dropperSpider
(
"Tamaño de arreglo en bytes: "
bind
tamanoShelf
)
;
dropperSpider
(
"Tamaño de conjunto en bytes: "
bind
tamanoChest
)
;
dropperSpider
(
"Tamaño de Punto en bytes: "
bind
tamanoPunto
)
;
Stack
tamanoVariable
=
chunk
entero
;
Stack
tamanoArreglo
=
chunk
arreglo
;
Stack
tamanoTexto
=
chunk
texto
;
dropperSpider
(
"Tamaño de variable entero en bytes: "
bind
tamanoVariable
)
;
dropperSpider
(
"Tamaño de variable arreglo en bytes: "
bind
tamanoArreglo
)
;
dropperSpider
(
"Tamaño de variable texto en bytes: "
bind
tamanoTexto
)
;
Stack
tamanoExpresion
=
chunk
(
entero
*
2
+
10
)
;
dropperSpider
(
"Tamaño de expresión en bytes: "
bind
tamanoExpresion
)
;
Stack
enteroDeFlotante
=
flotante
>
>
Stack
;
dropperSpider
(
"Flotante convertido a entero: "
bind
enteroDeFlotante
)
;
Torch
booleanoDeEntero
=
entero
>
>
Torch
;
dropperSpider
(
"Entero convertido a booleano: "
bind
booleanoDeEntero
)
;
Rune
caracterDeTexto
=
texto
>
>
Rune
;
dropperSpider
(
"Primer carácter del texto: "
bind
caracterDeTexto
)
;
Stack
resultadoEntero
=
(
flotante
:
+
2.5
)
>
>
Stack
;
dropperSpider
(
"Suma flotante convertida a entero: "
bind
resultadoEntero
)
;
Stack
tam1
=
chunkStack
;
Stack
tam2
=
chunk
Stack
;
Stack
tam3
=
chunk
(
Stack
)
;
Stack
ent1
=
flotante
>
>
Stack
;
Stack
ent2
=
flotante
>
>
Stack
;
Stack
tam4
=
chunk
Stack
;
Stack
ent3
=
flotante
>
>
Stack
;
Stack
tam5
=
chunk
Stack
;
Stack
ent4
=
flotante
>
>
Stack
;
Stack
tamCombinado
=
chunk
(
flotante
>
>
Stack
)
;
Spider
textoMayor
=
"Esto no es una coherción >>"
;
Spider
textoChunk
=
"La palabra chunk no es un operador aquí"
;
Stack
resultado
=
(
flotante
:
*
2.0
>
>
Stack
)
+
(
entero
*
3
)
;
target
(
flotante
>
>
Stack
)
>
3
craft
hit
PolloCrudo
dropperSpider
(
"La parte entera de flotante es mayor que 3"
)
;
PolloAsado
PolloAsado
worldSave
WorldName
PruebaComLinea
:
Bedrock
Obsidian
Stack
MAX_LEVEL
100
;
Obsidian
Spider
VERSION
"1.0"
;
Inventory
Stack
contador
=
0
;
Spider
texto
=
"Notch Engine"
;
Rune
inicial
;
Stack
a
=
10
,
b
=
20
;
Recipe
Spell
calcular
(
Stack
::
a
,
b
)
->
Stack
;
CraftingTable
Spell
calcular
(
Stack
::
a
,
b
)
->
Stack
PolloCrudo
Stack
resultado
=
a
+
b
;
respawn
resultado
;
PolloAsado
Ritual
mostrarMensaje
(
Spider
::
mensaje
)
PolloCrudo
dropperSpider
(
mensaje
)
;
PolloAsado
SpawnPoint
PolloCrudo
contador
=
5
;
target
contador
>
0
craft
hit
PolloCrudo
dropperSpider
(
"Contador positivo"
)
;
PolloAsado
Stack
resultado
=
contador
+
10
;
Stack
suma
=
calcular
(
5
,
10
)
;
;
PolloAsado
worldSave
WorldName
PruebaComBloque
:
Bedrock
Obsidian
Stack
MAX_LEVEL
100
;
Obsidian
Spider
VERSION
"1.0"
;
Inventory
Stack
contador
=
0
;
Spider
texto
=
"Notch Engine"
;
Rune
inicial
;
Stack
a
=
10
,
b
=
20
;
Recipe
Spell
calcular
(
Stack
::
a
,
b
)
->
Stack
;
CraftingTable
Spell
calcular
(
Stack
::
a
,
b
)
->
Stack
PolloCrudo
Stack
resultado
=
a
+
b
;
respawn
resultado
;
PolloAsado
Ritual
mostrarMensaje
(
Spider
::
mensaje
)
PolloCrudo
dropperSpider
(
mensaje
)
;
PolloAsado
SpawnPoint
PolloCrudo
contador
=
5
+
10
;
target
contador
>
0
craft
hit
PolloCrudo
dropperSpider
(
"Contador positivo"
)
;
PolloAsado
dentro
pero
sin
cerrar
aún
*
secuencias
*
PolloAsado
worldSave
WorldName
PruebaComentarios
:
Inventory
Stack
contador
=
10
;
Spider
texto
=
"Comentario /* falso */ dentro de un string"
;
Rune
caracter
=
'*'
;
SpawnPoint
PolloCrudo
dropperSpider
(
"Los comentarios son importantes"
)
;
PolloAsado
worldSave
WorldName
PruebaIdentificadoresSimples
:
Bedrock
Obsidian
Stack
MAX
100
;
Obsidian
Spider
TITULO
"Notch Engine"
;
Inventory
Stack
a
;
Stack
contador
;
Stack
nivel
;
Stack
x
;
Stack
y
;
Stack
z
;
Stack
posicion
;
Stack
altura
;
Stack
ancho
;
Spider
nombre
;
Spider
texto
;
Spider
mensaje
;
Spider
saludo
;
Torch
activo
;
Torch
visible
;
Torch
terminado
;
Rune
inicial
;
Rune
caracter
;
Rune
simbolo
;
Ghast
pi
;
Ghast
temperatura
;
Ghast
velocidad
;
Stack
Contador
;
Spider
Nombre
;
Torch
Activo
;
Stack
i
;
Stack
j
;
Stack
k
;
Rune
c
;
Spider
s
;
Torch
b
;
Ghast
f
;
CraftingTable
Spell
suma
(
Stack
::
a
,
b
)
->
Stack
PolloCrudo
Stack
resultado
;
resultado
=
a
+
b
;
respawn
resultado
;
PolloAsado
Ritual
imprimir
(
Spider
::
mensaje
)
PolloCrudo
dropperSpider
(
mensaje
)
;
PolloAsado
SpawnPoint
PolloCrudo
Stack
valor
;
Stack
resultado
;
Spider
mensaje
;
valor
=
10
;
mensaje
=
"Hola"
;
resultado
=
valor
+
5
;
valor
=
suma
(
valor
,
20
)
;
ender_pearl
imprimir
(
mensaje
)
;
PolloAsado
worldSave
WorldName
PruebaIdentificadoresComplejos
:
Bedrock
Obsidian
Stack
MAX_LEVEL
100
;
Obsidian
Stack
MIN_LEVEL
1
;
Obsidian
Spider
GAME_TITLE
"Notch Engine"
;
Obsidian
Spider
VERSION_1_0
"v1.0"
;
Inventory
Stack
player_level
;
Stack
enemy_count
;
Stack
max_health
;
Stack
min_damage
;
Stack
current_position_x
;
Stack
counter1
;
Stack
item2
;
Stack
level3d
;
Stack
position2d
;
Stack
player1_health
;
Stack
item_1
;
Stack
player_2_score
;
Stack
enemy_level_3
;
Stack
position_x_1
;
Stack
inventory_slot_5
;
Stack
_temp
;
Stack
_internal_counter
;
Stack
_system_value
;
Stack
_player_data
;
Stack
very_long_variable_name_with_many_words
;
Spider
extremely_long_message_text_that_describes_something_in_detail
;
Torch
is_player_currently_in_creative_mode_with_flight_enabled
;
Stack
player5_current_health_max_100
;
Stack
enemy_3d_position_coordinate_x_12
;
Rune
player_initial_1
;
Spider
user_5_name
;
CraftingTable
Spell
calculate_total_damage
(
Stack
::
base_damage
,
critical_multiplier
;
Torch
::
is_headshot
)
->
Stack
PolloCrudo
Stack
total_damage
;
total_damage
=
base_damage
*
critical_multiplier
;
target
is_headshot
craft
hit
PolloCrudo
total_damage
=
total_damage
*
2
;
PolloAsado
respawn
total_damage
;
PolloAsado
Ritual
display_player_stats
(
Spider
::
player_name
;
Stack
level_1
,
health_points_100
)
PolloCrudo
dropperSpider
(
"Player: "
bind
player_name
)
;
dropperSpider
(
"Level: "
bind
level_1
)
;
dropperSpider
(
"Health: "
bind
health_points_100
)
;
PolloAsado
SpawnPoint
PolloCrudo
Stack
player1_health
=
100
;
Stack
enemy_count_5
=
10
;
Spider
main_player_name
=
"Steve_123"
;
player1_health
=
player1_health
-
20
;
enemy_count_5
=
calculate_total_damage
(
10
,
2
,
On
)
;
ender_pearl
display_player_stats
(
main_player_name
,
5
,
player1_health
)
;
Stack
___special_value
=
42
;
dropperStack
(
___special_value
)
;
PolloAsado
worldSave
WorldName
PruebaIdentificadoresSimilares
:
Bedrock
Obsidian
Stack
WorldNameTest
100
;
Obsidian
Spider
BedrockType
"Hard Stone"
;
Obsidian
Torch
InventoryFull
On
;
Inventory
Stack
worldname
;
Stack
WorldName2
;
Stack
bedrock
;
Stack
Bedrock_Type
;
Stack
inventory
;
Stack
InventorySlot
;
Stack
recipe
;
Stack
RecipeBook
;
Stack
craftingtable
;
Stack
CraftingTable2
;
Stack
spawnpoint
;
Stack
SpawnPoint_Main
;
Stack
stack
;
Spider
spider
;
Torch
torch
;
Rune
rune
;
Ghast
ghast
;
Chest
chest
;
Book
book
;
Stack
pollocrudo
;
Stack
PolloAsado
;
Stack
polloAsadoExtra
;
Stack
repeater
;
Stack
target
;
Stack
hit
;
Stack
miss
;
Stack
craft
;
Stack
jukebox
;
Stack
disc
;
Stack
silence
;
Stack
spawner
;
Stack
exhausted
;
Stack
walk
;
Stack
set
;
Stack
to
;
Stack
step
;
Stack
wither
;
Stack
creeper
;
Stack
enderPearl
;
Stack
enderpearlitem
;
Stack
ragequit
;
Stack
spell
;
Stack
Spell_Cast
;
Stack
ritual
;
Stack
RitualCeremony
;
Stack
respawn
;
Stack
respawnPoint
;
Stack
ender_pearl
;
Stack
enderpearlTeleport
;
Stack
soulsand
;
Stack
SoulSandBlock
;
Stack
magma
;
Stack
MagmaBlock
;
Stack
and
;
Stack
andOperator
;
Stack
or
;
Stack
orGate
;
Stack
not
;
Stack
notOperator
;
Stack
xor
;
Stack
xorCalculation
;
Stack
is
;
Stack
isNot
;
Stack
isEqual
;
Torch
on
;
Torch
onSwitch
;
Torch
off
;
Torch
offState
;
Stack
hopper
;
Stack
hopperMinecart
;
Stack
dropper
;
Stack
dropperFunction
;
CraftingTable
Spell
worldNameGenerator
(
)
->
Spider
PolloCrudo
Spider
spawnpoint
=
"DefaultSpawn"
;
Stack
craft
=
10
;
Spider
ritual
=
"Magic"
;
respawn
"Generated"
;
PolloAsado
Ritual
craftingTableMaker
(
Spider
::
recipe
;
Stack
inventory
)
PolloCrudo
Stack
spell
=
20
;
Stack
worldname
=
30
;
Torch
on
=
Off
;
dropperSpider
(
"Crafting table ready"
)
;
PolloAsado
SpawnPoint
PolloCrudo
Stack
worldname
=
1
;
Stack
bedrock
=
2
;
Stack
inventory
=
3
;
Stack
recipe
=
4
;
Stack
craftingtable
=
5
;
Stack
spawnpoint
=
6
;
worldname
=
worldname
+
bedrock
;
inventory
=
craftingtable
*
spawnpoint
;
target
worldname
>
recipe
craft
hit
PolloCrudo
Spider
spell
=
"Magic"
;
dropperSpider
(
spell
)
;
PolloAsado
Spider
generatedName
=
worldNameGenerator
(
)
;
ender_pearl
craftingTableMaker
(
"New Recipe"
,
inventory
)
;
PolloAsado
worldSave
WorldName
PruebaStringsLargos
:
Inventory
Spider
string_normal
=
"Este es un string normal"
;
Spider
string_largo
=
"Este es un string extremadamente largo para probar cómo maneja el analizador léxico los tokens de gran tamaño. El propósito es verificar si el buffer del analizador puede manejar correctamente cadenas que exceden el tamaño típico. En Minecraft, los jugadores pueden construir estructuras enormes y elaboradas, similar a cómo este string se extiende más allá de los límites normales. Las cadenas largas son útiles para almacenar textos extensos como descripciones, historias, o mensajes de diálogo en juegos. Este string sigue creciendo para asegurar que supere los límites habituales de procesamiento del analizador léxico."
;
Spider
string_muy_largo
=
"Este string es aún más largo que el anterior, llegando a aproximadamente mil caracteres para poner realmente a prueba los límites del analizador léxico. En el desarrollo de compiladores, es importante verificar cómo responde el sistema ante casos extremos. Los buffers mal dimensionados podrían causar desbordamientos o truncamientos inesperados. En el mundo de Minecraft, esto sería comparable a construir una megaestructura que se extiende hasta los límites permitidos del mundo. Es crucial que el compilador maneje correctamente estos casos límite, ya que en aplicaciones reales, los usuarios pueden introducir textos extremadamente largos, como documentación, logs detallados, o incluso código generado automáticamente. Este string continúa creciendo, añadiendo más y más caracteres para asegurar que pruebe adecuadamente la capacidad del buffer del analizador léxico. Una implementación robusta debería ser capaz de manejar este token sin problemas, reconociéndolo correctamente como un único string literal, sin importar su longitud. El tamaño máximo debería estar limitado únicamente por la memoria disponible en el sistema, no por limitaciones arbitrarias en el diseño del analizador léxico. Este string sigue y sigue, añadiendo más palabras y caracteres, para garantizar que realmente ponga a prueba los límites del analizador."
;
Spider
string_con_escapes
=
"Este string incluye secuencias de escape como: \n nueva línea, \t tabulación, \" comillas dobles, \\ barra invertida, y otros caracteres especiales como !@#$%^&*()_+-={}[]|:;<>,.?/~`"
;
Spider
string_multilinea
=
"Línea 1\nLínea 2\nLínea 3\nLínea 4\nLínea 5\nLínea 6\nLínea 7\nLínea 8\nLínea 9\nLínea 10\nLínea 11\nLínea 12\nLínea 13\nLínea 14\nLínea 15\nLínea 16\nLínea 17\nLínea 18\nLínea 19\nLínea 20"
;
Spider
string_simbolos
=
"Este string contiene símbolos que son tokens en Notch Engine: +, -, *, //, %, :+, :-, :*, :%, ://, @, [], {}, {: :}, {/ /}, >>. También incluye palabras reservadas como WorldName, Inventory, SpawnPoint, craft, respawn, soulsand, magma, etc."
;
Spider
string_extremo
=
"Este string es extremadamente largo AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA, superando los dos mil caracteres para realmente llevar al límite la capacidad del analizador léxico. En el desarrollo de compiladores e intérpretes, es fundamental probar cómo maneja el sistema casos extremos como este. Cualquier limitación no prevista en el diseño podría manifestarse al procesar tokens de este tamaño. En Minecraft, esto sería equivalente a construir una estructura colosal que se extiende por miles de bloques en todas direcciones, poniendo a prueba los límites del motor del juego. Los analizadores léxicos deben estar preparados para manejar tokens de cualquier longitud razonable, ya que en aplicaciones del mundo real, los usuarios pueden necesitar procesar textos extremadamente largos. Ejemplos incluyen el procesamiento de documentos completos, archivos de configuración extensos, o incluso código generado automáticamente que puede extenderse por miles de líneas. Este string sigue creciendo, añadiendo más y más palabras y caracteres, para asegurar que realmente ponga a prueba los límites del buffer del analizador. Una implementación robusta debería manejar este token sin problemas, reconociéndolo correctamente como un único string literal completo, sin importar su tamaño. El tamaño máximo debería estar limitado únicamente por la memoria disponible en el sistema, no por limitaciones arbitrarias en el diseño del analizador. Este string continúa expandiéndose, añadiendo más contenido para garantizar que supere cualquier buffer de tamaño fijo que pueda haber sido implementado. Es importante también verificar que el rendimiento del analizador no se degrade exponencialmente con tokens muy grandes, lo que podría indicar algoritmos ineficientes. En el contexto de Notch Engine, inspirado en Minecraft, este string sería como un libro dentro del juego con una historia increíblemente detallada que se extiende por múltiples páginas. El analizador léxico debe procesar este token de manera eficiente, reconociéndolo como un único string literal y no fragmentándolo incorrectamente en múltiples tokens. Este string sigue creciendo, agregando más y más caracteres, para asegurar que realmente ponga a prueba los límites del analizador léxico. Continúa expandiéndose, como un mundo de Minecraft que se genera infinitamente, añadiendo más palabras y frases para llegar a una longitud verdaderamente extrema. Este string sigue y sigue y sigue, desafiando las capacidades del analizador, probando su robustez y eficiencia al manejar casos extremos como este."
;
SpawnPoint
PolloCrudo
dropperSpider
(
"Prueba de strings largos completada"
)
;
Stack
longitud
=
#
(
string_largo
)
;
dropperStack
(
longitud
)
;
Spider
subcadena
=
from
string_largo
#
#
0
#
#
50
;
dropperSpider
(
subcadena
)
;
PolloAsado
worldSave
WorldName
PruebaNumeroGrande
:
Bedrock
Obsidian
Stack
NUM_PEQUENO
42
;
Obsidian
Stack
NUM_MEDIANO
12345
;
Obsidian
Stack
NUM_GRANDE
9876543210
;
Obsidian
Stack
NUM_MUY_GRANDE
1234567890123456789
;
Obsidian
Stack
NEG_PEQUENO
-
42
;
Obsidian
Stack
NEG_MEDIANO
-
12345
;
Obsidian
Stack
NEG_GRANDE
-
9876543210
;
Obsidian
Stack
NEG_MUY_GRANDE
-
1234567890123456789
;
Obsidian
Stack
INT_16BIT_MAX
32767
;
Obsidian
Stack
INT_16BIT_MIN
-
32768
;
Obsidian
Stack
INT_32BIT_MAX
2147483647
;
Obsidian
Stack
INT_32BIT_MIN
-
2147483648
;
Obsidian
Stack
INT_64BIT_MAX
9223372036854775807
;
Obsidian
Stack
INT_64BIT_MIN
-
9223372036854775808
;
Obsidian
Stack
NUM_EXTREMO
123456789012345678901234567890
;
Obsidian
Stack
NEG_EXTREMO
-
123456789012345678901234567890
;
Inventory
Stack
num1
=
1234567890
;
Stack
num2
=
9876543210
;
Stack
grande1
=
123456789012345678
;
Stack
grande2
=
987654321098765432
;
Stack
max16
=
32767
;
Stack
min16
=
-
32768
;
Stack
max32
=
2147483647
;
Stack
min32
=
-
2147483648
;
Stack
max64
=
9223372036854775807
;
Stack
min64
=
-
9223372036854775808
;
Stack
extremo
=
123456789012345678901234567890
;
Shelf
[
2147483647
]
Stack
arregloGrande
;
Stack
suma
;
Stack
resta
;
Stack
multiplicacion
;
Stack
division
;
Stack
modulo
;
SpawnPoint
PolloCrudo
suma
=
num1
+
num2
;
resta
=
num2
-
num1
;
multiplicacion
=
num1
*
10
;
division
=
num2
10
;
modulo
=
num2
%
10
;
Stack
resultado1
=
grande1
+
grande2
;
Stack
resultado2
=
extremo
1000
;
Stack
posible_overflow
=
max32
+
1
;
Stack
posible_underflow
=
min32
-
1
;
Stack
producto_grande
=
grande1
*
grande2
;
Stack
division_extrema
=
extremo
3
;
dropperStack
(
suma
)
;
dropperStack
(
resta
)
;
dropperStack
(
multiplicacion
)
;
dropperStack
(
division
)
;
target
producto_grande
>
0
craft
hit
PolloCrudo
dropperSpider
(
"El resultado es positivo"
)
;
PolloAsado
Stack
i
=
0
;
repeater
i
<
5
craft
PolloCrudo
dropperStack
(
i
)
;
dropperStack
(
grande1
)
;
soulsand
i
;
PolloAsado
PolloAsado
worldSave
WorldName
PruebaPrecisionFlotante
:
Bedrock
Obsidian
Ghast
PI_SIMPLE
3.14
;
Obsidian
Ghast
PI_PRECISO
3.14159265358979323846
;
Obsidian
Ghast
EULER
2.71828182845904523536
;
Obsidian
Ghast
RAIZ_DOS
1.41421356237309504880
;
Obsidian
Ghast
PHI
1.61803398874989484820
;
Obsidian
Ghast
SPEED_OF_LIGHT
2.99792458
e8
;
Obsidian
Ghast
PLANCK_CONSTANT
6.62607015
e
-
34
;
Obsidian
Ghast
AVOGADRO
6.02214076
e23
;
Obsidian
Ghast
EXTREMO_PEQUENO
0.0000000000000000000000001
;
Obsidian
Ghast
EXTREMO_GRANDE
123456789012345678901234.5678901234567890
;
Obsidian
Ghast
NEG_PI
-
3.14159265358979
;
Obsidian
Ghast
NEG_EXTREMO
-
0.0000000000000000000000001
;
Obsidian
Ghast
CERO_DECIMAL
0.0
;
Obsidian
Ghast
SOLO_ENTERO
42.0
;
Obsidian
Ghast
SOLO_DECIMAL
0.42
;
Obsidian
Ghast
PUNTO_INICIAL
.
5
;
Inventory
Ghast
normal
=
3.14
;
Ghast
preciso
=
3.141592653589793
;
Ghast
pequeno
=
0.000000000123
;
Ghast
grande
=
1234567890.123456789
;
Ghast
punto_inicial
=
.
25
;
Ghast
sin_decimal
=
42
.
;
Ghast
cientifico1
=
1.23
e5
;
Ghast
cientifico2
=
4.56
e
-
7
;
Ghast
cientifico3
=
7.89
e
+
12
;
Ghast
muy_pequeno
=
0.000000000000000000000000000000000001
;
Ghast
muy_grande
=
999999999999999999999999999999999999999.9
;
Ghast
muchos_digitos
=
123456789012345.678901234567890
;
Ghast
neg_normal
=
-
3.14
;
Ghast
neg_preciso
=
-
3.141592653589793
;
Ghast
neg_pequeno
=
-
0.000000000123
;
Ghast
neg_cientifico
=
-
2.998
e8
;
Ghast
resultado1
;
Ghast
resultado2
;
Ghast
resultado3
;
SpawnPoint
PolloCrudo
resultado1
=
normal
:
+
preciso
;
resultado2
=
preciso
:
-
normal
;
resultado3
=
normal
:
*
2.0
;
Ghast
res_extremo1
=
muy_pequeno
:
*
1000000.0
;
Ghast
res_extremo2
=
muy_grande
:
1000000.0
;
Ghast
division1
=
1.0
:
3.0
;
Ghast
division2
=
2.0
:
3.0
;
Ghast
division_extrema
=
1.0
:
9999999999.0
;
Ghast
res_cientifico
=
cientifico1
:
*
cientifico2
;
dropperGhast
(
resultado1
)
;
dropperGhast
(
resultado2
)
;
dropperGhast
(
division1
)
;
dropperGhast
(
division2
)
;
target
division1
:
<
0.34
craft
hit
PolloCrudo
dropperSpider
(
"La división 1/3 es menor que 0.34"
)
;
PolloAsado
Ghast
i
=
0.0
;
repeater
i
:
<
1.0
craft
PolloCrudo
dropperGhast
(
i
)
;
i
=
i
:
+
0.2
;
PolloAsado
PolloAsado
worldSave
WorldName
PruebaComentarioLargo
:
Inventory
Stack
contador
=
0
;
Stack
despues_comentario
=
1
;
Spider
mensaje
=
"Prueba de comentarios largos"
;
SpawnPoint
PolloCrudo
Stack
i
=
0
;
repeater
i
<
5
craft
PolloCrudo
soulsand
i
;
dropperSpider
(
mensaje
bind
" - iteración "
bind
i
)
;
PolloAsado
dropperSpider
(
"Prueba de comentarios largos completada"
)
;
PolloAsado
worldSave
WorldName
PruebaTokensConsecutivos
:
Bedrock
Obsidian
Stack
MAX_LEVEL5
100
;
Obsidian
Stack
LEVEL_PLUS_SKILL
200
;
Obsidian
Stack
OFFSET_MINUS_5
50
;
Inventory
Stack
a
=
5
;
Stack
b
=
10
;
Stack
c
=
a
+
b
;
Stack
suma
=
5
+
3
;
Stack
resta
=
10
-
7
;
Stack
multiplicacion
=
4
*
3
;
Stack
division
=
20
4
;
Stack
modulo
=
7
%
2
;
Torch
comparacion1
=
5
<
10
;
Torch
comparacion2
=
5
>
3
;
Torch
comparacion3
=
5
<=
5
;
Torch
comparacion4
=
5
>=
5
;
Torch
comparacion5
=
5
is5
;
Torch
comparacion6
=
5
isNot6
;
Stack
expr1
=
5
+
3
*
2
;
Stack
expr2
=
(
5
+
3
)
*
2
;
Stack
expr3
=
5
+
(
3
*
2
)
;
Ghast
f1
=
3.14
;
Ghast
f2
=
f1
:
+
2.5
;
Ghast
f3
=
f1
:
-
1.5
;
Ghast
f4
=
f1
:
*
2.0
;
Ghast
f5
=
f1
:
1.5
;
Shelf
[
5
]
Stack
arreglo
;
Entity
Jugador
PolloCrudo
Spider
nombre
;
Stack
nivel
;
PolloAsado
;
Spider
texto
=
"Hola"
;
Rune
caracter
=
'A'
;
Torch
booleano
=
On
;
Stack
arr
[
0
]
=
10
;
Stack
x
=
1
,
y
=
2
,
z
=
3
;
Stack
normal1
=
10
;
Stack
normal2
=
20
;
Spider
mensaje
=
"Tokens consecutivos"
;
SpawnPoint
PolloCrudo
suma
=
normal1
+
normal2
;
Stack
valor
=
(
normal1
+
5
)
*
(
normal2
-
5
)
;
repeater
suma
>
0
hit
PolloCrudo
suma
=
suma
-
1
;
dropperStack
(
suma
)
;
PolloAsado
target
valor
>=
100
hit
PolloCrudo
dropperSpider
(
"Valor grande"
)
;
PolloAsado
miss
PolloCrudo
dropperSpider
(
"Valor pequeño"
)
;
PolloAsado
dropperSpider
(
mensaje
)
;
dropperStack
(
valor
)
;
normal1
+
=
5
;
normal2
-
=
3
;
dropperStack
(
normal1
)
;
dropperStack
(
normal2
)
;
PolloAsado
worldSave
WorldName
PruebaCaracteresInvalidos
:
Bedrock
Obsidian
Stack
NORMAL
100
;
Obsidian
Stack
ÑANDU
200
;
Obsidian
Stack
AÇÚCAR
300
;
Obsidian
Stack
CAFÉ
400
;
Inventory
Stack
contador
=
0
;
Spider
mensaje
=
"Normal"
;
Stack
año
=
2025
;
Stack
piña
=
10
;
Spider
münzen
=
"Monedas"
;
Spider
öffentlich
=
"Público"
;
Stack
cont
ador
=
5
;
Spider
mens
aje
=
"Texto"
;
Stack
contador
=
10
;
Spider
mensaje
=
"Texto"
;
Stack
monedas
=
100
;
Stack
valor
=
50
;
Spider
texto
=
"Copyright"
;
Spider
texto_unicode
=
"Caracteres especiales: áéíóúñÁÉÍÓÚÑ"
;
Spider
texto_emoji
=
"Emojis: 😀🎮🌍💻"
;
Stack
a
b
;
Stack
c
d
;
Stack
e
f
;
Stack
g
h
;
Stack
valor
otro
;
Stack
valor
contador
=
5
;
Stack
otro
valor
=
10
;
Rune
char_1
=
'€'
;
Rune
char_2
=
'✓'
;
SpawnPoint
PolloCrudo
contador
=
1
;
contador
=
contador
2
;
contador
=
contador
2
;
dropperStack
(
año
)
;
dropperSpider
(
texto_unicode
)
;
contador
=
5
10
;
contador
=
5
10
;
contador
=
5
;
contador
=
contador
+
5
;
dropperSpider
(
"Fin de prueba"
)
;
PolloAsado
worldSave
WorldName
PruebaStringNoTerminado
:
Bedrock
Obsidian
Spider
NOMBRE
"Notch Engine"
;
Obsidian
Spider
VERSION
"1.0"
;
Obsidian
Spider
DESCRIPCION
"Un lenguaje basado en Minecraft;
$$ Constante después del error para verificar recuperación
Obsidian Stack MAX_NIVEL 100;
Inventory
$$ Variables con strings correctamente terminados
Spider normal = "
Este
string
está
bien
";
Spider multilinea = "
Este
string
tiene
nmúltiples
líneas
ny
está
bien
terminado
";
$$ Variable con string no terminado - falta comilla de cierre
Spider incompleto = "
Este
string
no
está
terminado
;
Stack
contador
=
0
;
Spider
confuso
=
"Este string tiene una comilla escapada \" pero no está terminado;
$$ String no terminado al final de una línea
Spider final_linea = "
Este
string
termina
la
línea
pero
no
está
cerrado
Spider
siguiente
=
"Este es un nuevo string"
;
Spider
combinado
=
"String no terminado Stack contador = 5;
$$ String con múltiples líneas pero sin terminar
Spider multilinea_incompleto = "
Este
string
tiene
múltiples
líneas
pero
no
está
terminado
correctamente
;
Spider
comentario_inmediato
=
"String terminado correctamente"
Spider
comentario_error
=
"String no terminado$$ Comentario que no salva el error
$$ String no terminado con comentario de bloque al final
Spider bloque_inmediato = "
String
no
terminado
Spider
consecutivo1
=
"Primer string terminado"
;
Spider
consecutivo2
=
"Segundo string no terminado;
Spider consecutivo3 = "
Tercer
string
terminado
";
SpawnPoint
PolloCrudo
$$ Código normal para contraste
dropperSpider("
Este
mensaje
está
bien
formado
");
$$ Instrucción con string no terminado
dropperSpider("
Este
mensaje
no
está
terminado
;
contador
=
1
;
Spider
resultado
=
normal
bind
"Parte no terminada;
$$ String no terminado en una estructura de control
target normal is "
Comparación
no
terminada
craft
hit
PolloCrudo
dropperSpider
(
"Este código nunca se ejecutará"
)
;
PolloAsado
dropperSpider
(
"String final no terminado
PolloAsado
worldSave
$*
Prueba_Err_ComentarioNoTerminado.ne
Propósito: Verificar detección de comentarios de bloque sin cierre
Fecha: 28/04/2025
*$
WorldName PruebaComentarioNoTerminado:
Bedrock
$$ Constantes normales para contraste
Obsidian Stack MAX_LEVEL 100;
$* Comentario de bloque correctamente cerrado *$
Obsidian Stack MIN_LEVEL 1;
$* Comentario de bloque sin cierre - falta el terminador *$
Obsidian Stack MEDIO_LEVEL 50;
Inventory
$$ Variables normales para contraste
Stack contador = 0;
Spider mensaje = "
Hola
Mundo
";
$*
Comentario de bloque multi-línea correctamente terminado
con varias líneas de texto
*$
Stack variable_normal = 5;
$*
Comentario de bloque multi-línea sin terminar
Este comentario no tiene el terminador correspondiente
y debería generar un error
Torch activo = On; $$ Esta línea no debería ser reconocida como código
Stack valor = 10; $$ Esta línea no debería ser reconocida como código
$$ Variables después del error para verificar recuperación
Stack recuperacion = 20;
$* Otro comentario no terminado
con símbolos que podrían confundir al analizador:
* asterisco suelto
$ signo dólar suelto
*$ esto parece un terminador pero no lo es
$* esto parece un iniciador dentro del comentario
$$ Más código después del segundo comentario no terminado
Torch otra_variable = Off;
$* Comentario aparentemente cerrado, pero con un espacio entre * y $
que debería causar que no se reconozca como terminador * $
$$ Código después del tercer comentario no terminado
Stack tercera_recuperacion = 30;
$*
Este comentario tiene una secuencia que parece un terminador,
pero tiene caracteres en medio: *texto$
Por lo tanto, no está realmente terminado.
$$ Último código para verificar recuperación
Stack ultima_recuperacion = 40;
SpawnPoint
PolloCrudo
$$ Código normal para contraste
dropperSpider("
Inicio
de
programa
");
$* Comentario de bloque sin terminar en el SpawnPoint
Esta sección del código no debería ejecutarse
contador = 5;
dropperStack(contador);
$$ Código después del comentario no terminado
Stack final = 100;
dropperStack(final);
dropperSpider("
Fin
de
programa
");
PolloAsado
$$ Esto debería ser código después del SpawnPoint, que no es válido
$$ pero el analizador léxico igual debería procesarlo como tokens
$*
Comentario final sin terminar
Este es el último elemento del archivo
worldSave
$*
Prueba: 37_Prueba_Err_CaracterNoTerminado
Descripción: Verificar detección de literales de carácter sin cierre
Fecha: 28/04/2025
*$
WorldName PruebaCaracterNoTerminado:
Inventory
$$ Casos de caracteres correctamente formados (para comparación)
Rune letraCorrecta = 'A';
Rune digitoCorrecto = '5';
Rune simboloCorrecto = '@';
Rune escapeCorrecto = '\n';
$$ Casos de caracteres sin cierre (errores léxicos)
Rune errorSimple = 'B; $$ Falta comilla de cierre
Rune errorEscape = '\n; $$ Falta comilla de cierre después de secuencia de escape
$$ Caso con apertura pero sin contenido ni cierre
Rune errorVacio = '; $$ Solo comilla de apertura
$$ Caso con múltiples caracteres (error léxico)
Rune errorMultiple = 'ABC; $$ Múltiples caracteres y falta comilla de cierre
$$ Error dentro de una expresión
Stack valor = 5 + (3 * 'x); $$ Falta comilla de cierre en la expresión
SpawnPoint
PolloCrudo
$$ Este carácter inválido debería ser detectado
Rune pruebaError = 'Z;
dropperSpider("
Este
texto
no
debería
ser
alcanzado
debido
al
error
léxico
");
PolloAsado
worldSave
$*
Prueba: 38_Prueba_Err_SimboloDesconocido
Descripción: Verificar detección de símbolos no reconocidos
Fecha: 28/04/2025
*$
WorldName PruebaSimboloDesconocido:
Bedrock
$$ Símbolos válidos para comparación
Obsidian Stack MAX_VALUE 100;
$$ Símbolo no reconocido: flecha de asignación errónea
Obsidian Stack MIN_VALUE => 0; $$ => no es un símbolo válido
Inventory
$$ Símbolos válidos (para comparación)
Stack contador = 10;
Stack resultado = contador + 5;
$$ Símbolos no reconocidos
Stack valor1 = 5 ^ 2; $$ ^ (potencia) no es un símbolo válido
Stack valor2 = 10 \ 3; $$ \ no es un operador válido
Stack valor3 = valor1 ~ valor2; $$ ~ no es un operador válido
$$ Operadores malformados o incompletos
Stack valor4 = 3 : 4; $$ : solo no es un operador válido (debe ser :+, :-, etc.)
Stack valor5 = 7 / 2; $$ / no es válido (debe ser // para división entera)
$$ Uso de símbolos de otros lenguajes
Stack valor6 = 5 ** 2; $$ ** (potencia en Python) no es válido
Torch condicion = (valor5 == valor6); $$ == no es válido (debe ser 'is')
$$ Símbolo inválido en acceso a estructura
Stack elemento = numeros->0; $$ -> no es válido para acceso (debe ser [])
ResourcePack
$$ Símbolo inválido en declaración de tipo
Anvil Stack ==> Spider; $$ ==> no es un símbolo válido (debe ser ->)
SpawnPoint
PolloCrudo
$$ Operadores inválidos en expresiones
Stack a = 5;
Stack b = 10;
Stack c = a ||| b; $$ ||| no es un operador válido
$$ Símbolos inválidos en estructuras de control
target a < b craft hit
PolloCrudo
dropperSpider("
a
es
menor
que
b
");
PolloAsado
?> $$ ?> no es un símbolo válido
$$ Símbolo inválido como terminador de instrucción
Stack valor = 100#
PolloAsado
worldSave
$*
Prueba: 39_Prueba_Comb_Estructura
Descripción: Verificar estructura básica de un programa completo
Fecha: 28/04/2025
*$
WorldName PruebaEstructuraCompleta:
$$ Sección de constantes
Bedrock
Obsidian Stack MAX_NIVEL 100;
Obsidian Spider VERSION "
1.0
.
0
";
Obsidian Torch DEBUG_MODE Off;
Obsidian Ghast PI 3.14159;
$$ Sección de tipos
ResourcePack
Anvil Ghast -> Stack truncate;
Anvil Stack -> Spider;
$$ Definición de un tipo personalizado
Entity Jugador
PolloCrudo
Spider nombre;
Stack nivel;
Ghast salud;
Torch activo;
PolloAsado;
$$ Sección de variables
Inventory
$$ Variables básicas
Stack contador = 0;
Spider mensaje = "
Bienvenido
a
Notch
Engine
";
Torch juego_activo = On;
Ghast temperatura = 21.5;
Chest letras = {: 'a', 'b', 'c' :};
$$ Variables compuestas
Shelf[5] Stack inventario;
Entity Jugador steve;
$$ Sección de prototipos
Recipe
$$ Prototipo de función
Spell calcularDanio(Stack :: nivel, arma; Ghast ref multiplicador) -> Stack;
$$ Prototipo de procedimiento
Ritual mostrarEstado(Spider :: nombre; Stack nivel, salud);
$$ Sección de implementación de rutinas
CraftingTable
$$ Implementación de función
Spell calcularDanio(Stack :: nivel, arma; Ghast ref multiplicador) -> Stack
PolloCrudo
Stack danio_base = nivel * 2;
target arma is 1 hit
PolloCrudo
danio_base *= 2; $$ Arma mejorada
PolloAsado
multiplicador = 1.5; $$ Modificar parámetro por referencia
respawn danio_base;
PolloAsado
$$ Implementación de procedimiento
Ritual mostrarEstado(Spider :: nombre; Stack nivel, salud)
PolloCrudo
dropperSpider("
==
==
=
Estado
del
Jugador
==
==
=
");
dropperSpider("
Nombre
:
" bind nombre);
dropperSpider("
Nivel
:
" bind nivel);
dropperSpider("
Salud
:
" bind salud);
dropperSpider("
==
==
==
==
==
==
==
==
==
==
==
==
==
==
=
");
PolloAsado
$$ Punto de entrada del programa
SpawnPoint
PolloCrudo
$$ Inicialización
steve@nombre = "
Steve
";
steve@nivel = 1;
steve@salud = 20.0;
steve@activo = On;
$$ Entrada y salida
dropperSpider(mensaje);
dropperSpider("
Ingrese
su
nombre
:
");
Spider nombre_jugador = hopperSpider();
$$ Uso de estructuras de control
target #(nombre_jugador) > 0 hit
PolloCrudo
dropperSpider("
Hola
,
" bind nombre_jugador bind "
");
$$ Uso de funciones y procedimientos
Stack danio = calcularDanio(steve@nivel, 1, 1.0);
dropperSpider("
Tu
daño
base
es
:
" bind danio);
ender_pearl mostrarEstado(steve@nombre, steve@nivel, steve@salud);
$$ Bucle
repeater juego_activo
PolloCrudo
dropperSpider("
Continuar
jugando
(
On
Off
)
");
juego_activo = hopperTorch();
target juego_activo hit
PolloCrudo
soulsand steve@nivel;
dropperSpider("
Nivel
aumentado
a
:
" bind steve@nivel);
PolloAsado
PolloAsado
PolloAsado
miss
PolloCrudo
dropperSpider("
Nombre
no
válido
.
");
PolloAsado
$$ Otros tipos de bucles
Stack i = 0;
spawner
PolloCrudo
soulsand i;
inventario[i] = i * 10;
PolloAsado
exhausted i >= 5;
walk j set 0 to 4
PolloCrudo
dropperSpider("
Inventario
[
" bind j bind "
]
:
" bind inventario[j]);
PolloAsado
PolloAsado
worldSave
$*
Prueba: 40_Prueba_Comb_Declaraciones
Descripción: Verificar combinaciones de declaraciones de variables y constantes
Fecha: 28/04/2025
*$
WorldName PruebaCombinacionDeclaraciones:
$$ Sección de constantes con diferentes tipos y complejidades
Bedrock
$$ Constantes simples de tipos básicos
Obsidian Stack MAX_PLAYERS 8;
Obsidian Stack MIN_LEVEL 1;
Obsidian Torch DEBUG_MODE On;
Obsidian Spider GAME_TITLE "
Notch
Engine
";
Obsidian Rune SEPARATOR '_';
Obsidian Ghast GRAVITY 9.8;
$$ Constantes con expresiones
Obsidian Stack MAX_INVENTORY_SIZE 5 * 9;
Obsidian Stack TOTAL_SLOTS MAX_PLAYERS * MAX_INVENTORY_SIZE;
Obsidian Spider FULL_TITLE GAME_TITLE bind "
v1
.
0
";
Obsidian Ghast TERMINAL_VELOCITY GRAVITY :* 3.0;
$$ Constantes con expresiones más complejas
Obsidian Stack DAYS_IN_YEAR 365;
Obsidian Stack DAYS_IN_4_YEARS DAYS_IN_YEAR * 4 + 1;
Obsidian Torch IS_LEAP_YEAR (DAYS_IN_4_YEARS - (DAYS_IN_YEAR * 4)) is 1;
$$ Declaraciones de tipos con diferentes formas
ResourcePack
$$ Conversiones de tipos básicas
Anvil Ghast -> Stack;
Anvil Ghast -> Stack truncate;
Anvil Stack -> Spider;
Anvil Rune -> Stack safe;
$$ Declaraciones de entidades (registros)
Entity Item
PolloCrudo
Spider nombre;
Stack cantidad;
Stack durabilidad;
Torch stackeable;
PolloAsado;
Entity Jugador
PolloCrudo
Spider nombre;
Stack nivel;
Stack experiencia;
Ghast salud;
Ghast hambre;
Torch en_linea;
Entity Item item_principal;
PolloAsado;
Entity Posicion
PolloCrudo
Stack x;
Stack y;
Stack z;
PolloAsado;
$$ Tipos anidados
Entity Mundo
PolloCrudo
Spider nombre;
Stack seed;
Shelf[10] Entity Jugador jugadores;
Entity Posicion spawn;
PolloAsado;
$$ Sección de variables con diferentes formas de declaración e inicialización
Inventory
$$ Declaraciones simples sin inicialización
Stack contador;
Spider mensaje;
Torch estado;
Rune inicial;
Ghast temperatura;
$$ Declaraciones con inicialización
Stack nivel = 1;
Spider nombre = "
Steve
";
Torch activo = On;
Rune tecla = 'A';
Ghast pi = 3.14159;
$$ Declaraciones múltiples del mismo tipo
Stack x = 0, y = 0, z = 0;
Torch jugando = On, pausa = Off, sonido = On;
Ghast distancia = 0.0, velocidad = 5.0, aceleracion = 1.5;
$$ Declaraciones con resultados de expresiones
Stack suma = 5 + 10;
Stack producto = 4 * 25;
Spider saludo = "
Hola
" bind nombre;
Torch condicion = nivel > 5;
Ghast promedio = (10.5 :+ 20.7 :+ 15.3) :// 3.0;
$$ Declaraciones de tipos compuestos
Shelf[5] Stack inventario;
Shelf[3] Spider mensajes = ["
Hola
", "
Mundo
", "
"];
Shelf[2] Shelf[2] Stack matriz;
Chest numeros = {: 1, 2, 3, 4, 5 :};
Book archivo = {/ "
datos
.
txt
", 'E' /};
$$ Instancias de entidades (registros)
Entity Item espada;
Entity Jugador jugador1
PolloCrudo
nombre: "
Alex
";
nivel: 5;
experiencia: 150;
salud: 18.5;
hambre: 16.0;
en_linea: On;
item_principal:
PolloCrudo
nombre: "
Espada
de
diamante
";
cantidad: 1;
durabilidad: 1500;
stackeable: Off;
PolloAsado;
PolloAsado;
Entity Mundo mundo_principal;
SpawnPoint
PolloCrudo
$$ Inicialización de variables declaradas sin valor inicial
contador = 0;
mensaje = "
Variable
inicializada
en
el
punto
de
entrada
";
estado = Off;
inicial = 'Z';
temperatura = 22.5;
$$ Inicialización de variables compuestas
espada@nombre = "
Espada
de
hierro
";
espada@cantidad = 1;
espada@durabilidad = 250;
espada@stackeable = Off;
matriz[0][0] = 1;
matriz[0][1] = 2;
matriz[1][0] = 3;
matriz[1][1] = 4;
mundo_principal@nombre = "
Mundo
de
prueba
";
mundo_principal@seed = 12345;
mundo_principal@spawn@x = 0;
mundo_principal@spawn@y = 64;
mundo_principal@spawn@z = 0;
$$ Uso de constantes en asignaciones
Stack max_jugadores = MAX_PLAYERS;
dropperSpider(FULL_TITLE);
$$ Uso de referencias a variables en asignaciones
Stack total = nivel + jugador1@nivel;
dropperSpider("
Nivel
total
:
" bind total);
PolloAsado
worldSave
$*
Prueba: 41_Prueba_Comb_Expresiones
Descripción: Verificar expresiones aritméticas y lógicas complejas
Fecha: 28/04/2025
*$
WorldName PruebaExpresionesComplejas:
Bedrock
Obsidian Stack BASE_DAMAGE 10;
Obsidian Stack ARMOR_FACTOR 2;
Obsidian Ghast CRIT_MULTIPLIER 1.5;
Obsidian Torch USE_ADVANCED_FORMULAS On;
Inventory
$$ Variables para las pruebas
Stack a = 5;
Stack b = 10;
Stack c = 15;
Stack resultado_entero;
Ghast x = 2.5;
Ghast y = 3.7;
Ghast z = 1.2;
Ghast resultado_flotante;
Torch p = On;
Torch q = Off;
Torch r = On;
Torch resultado_logico;
Spider str1 = "
Notch
";
Spider str2 = "
Engine
";
Spider resultado_string;
Shelf[5] Stack valores = [10, 20, 30, 40, 50];
Entity Jugador
PolloCrudo
Spider nombre;
Stack nivel;
Ghast salud;
PolloAsado;
Entity Jugador jugador;
SpawnPoint
PolloCrudo
$$ 1. Expresiones aritméticas complejas con enteros
resultado_entero = a + b * c;
dropperSpider("
a
+
b
*
c
=
" bind resultado_entero);
resultado_entero = (a + b) * c;
dropperSpider("
(
a
+
b
)
*
c
=
" bind resultado_entero);
resultado_entero = a + b - c * 2 // 3 % 4;
dropperSpider("
a
+
b
-
c
*
2
3
%
4
=
" bind resultado_entero);
resultado_entero = (a + (b - (c * (2 // (3 % 4)))));
dropperSpider("
Anidada
enteros
:
" bind resultado_entero);
soulsand a;
resultado_entero = a + b;
magma b;
dropperSpider("
Después
de
incremento
decremento
:
" bind resultado_entero);
$$ 2. Expresiones aritméticas complejas con flotantes
resultado_flotante = x :+ y :* z;
dropperSpider("
x
:
+
y
:
*
z
=
" bind resultado_flotante);
resultado_flotante = (x :+ y) :* z;
dropperSpider("
(
x
:
+
y
)
:
*
z
=
" bind resultado_flotante);
resultado_flotante = x :+ y :- z :* 2.0 :// 0.5 :% 1.0;
dropperSpider("
x
:
+
y
:
-
z
:
*
2.0
:
0.5
:
%
1.0
=
" bind resultado_flotante);
resultado_flotante = (x :+ (y :- (z :* (2.0 :// (0.5 :% 1.0)))));
dropperSpider("
Anidada
flotantes
:
" bind resultado_flotante);
$$ 3. Expresiones lógicas complejas
resultado_logico = p and q;
dropperSpider("
p
and
q
=
" bind resultado_logico);
resultado_logico = p or q;
dropperSpider("
p
or
q
=
" bind resultado_logico);
resultado_logico = not p;
dropperSpider("
not
p
=
" bind resultado_logico);
resultado_logico = p xor q;
dropperSpider("
p
xor
q
=
" bind resultado_logico);
resultado_logico = p and q or r;
dropperSpider("
p
and
q
or
r
=
" bind resultado_logico);
resultado_logico = p and (q or r);
dropperSpider("
p
and
(
q
or
r
)
=
" bind resultado_logico);
resultado_logico = not (p and q) or (not r and p);
dropperSpider("
not
(
p
and
q
)
or
(
not
r
and
p
)
=
" bind resultado_logico);
$$ 4. Expresiones de comparación
resultado_logico = a < b;
dropperSpider("
a
<
b
=
" bind resultado_logico);
resultado_logico = a > c;
dropperSpider("
a
>
c
=
" bind resultado_logico);
resultado_logico = a <= b and b >= c;
dropperSpider("
a
<=
b
and
b
>=
c
=
" bind resultado_logico);
resultado_logico = (a is b) or (b is c);
dropperSpider("
(
a
is
b
)
or
(
b
is
c
)
=
" bind resultado_logico);
resultado_logico = a isNot b and b isNot c and a isNot c;
dropperSpider("
a
isNot
b
and
b
isNot
c
and
a
isNot
c
=
" bind resultado_logico);
$$ 5. Expresiones mixtas (combinando tipos)
resultado_logico = (a + b > c) and (x :+ y :> z);
dropperSpider("
(
a
+
b
>
c
)
and
(
x
:
+
y
:
>
z
)
=
" bind resultado_logico);
resultado_logico = (a < b) or (not p) and (x :< y);
dropperSpider("
(
a
<
b
)
or
(
not
p
)
and
(
x
:
<
y
)
=
" bind resultado_logico);
$$ 6. Expresiones con operaciones de cadenas
resultado_string = bind(str1, "
" bind str2);
dropperSpider("
bind
result
:
" bind resultado_string);
Stack longitud = #(resultado_string);
dropperSpider("
Length
:
" bind longitud);
resultado_string = from resultado_string ## 0 ## 5;
dropperSpider("
Substring
:
" bind resultado_string);
Stack pos = seek(resultado_string, "
tch
");
dropperSpider("
Position
of
'tch'
:
" bind pos);
$$ 7. Expresiones con accesos a estructuras
Stack valor_arreglo = valores[2] + valores[3] * valores[4];
dropperSpider("
Array
expression
:
" bind valor_arreglo);
jugador@nombre = "
Steve
";
jugador@nivel = 20;
jugador@salud = 18.5;
Stack nivel_con_bonus = jugador@nivel + 5;
dropperSpider("
Nivel
con
bonus
:
" bind nivel_con_bonus);
Torch nivel_alto = jugador@nivel > 15 and jugador@salud :> 15.0;
dropperSpider("
Nivel
alto
:
" bind nivel_alto);
$$ 8. Expresiones con conversiones de tipo
Stack entero_desde_float = x >> Stack;
dropperSpider("
Entero
desde
float
:
" bind entero_desde_float);
Torch bool_desde_entero = a >> Torch;
dropperSpider("
Booleano
desde
entero
:
" bind bool_desde_entero);
$$ 9. Expresiones extremadamente complejas que combinan múltiples elementos
Stack damage = BASE_DAMAGE + ((jugador@nivel // 2) * (valores[1] + valores[3] // 3));
dropperSpider("
Daño
calculado
:
" bind damage);
target USE_ADVANCED_FORMULAS craft hit
PolloCrudo
Ghast damage_final = ((damage >> Ghast) :* CRIT_MULTIPLIER) :// (1.0 :+ ((valores[4] // 10) >> Ghast));
dropperSpider("
Daño
final
(
fórmula
avanzada
)
:
" bind damage_final);
PolloAsado
miss
PolloCrudo
Stack damage_simple = damage * 2 // (ARMOR_FACTOR + (p and q >> Stack));
dropperSpider("
Daño
final
(
fórmula
simple
)
:
" bind damage_simple);
PolloAsado
PolloAsado
worldSave
$*
Prueba: 42_Prueba_Comb_Control.ne
Descripción: Verificar estructuras de control anidadas
Fecha: 28/04/2025
*$
WorldName PruebaControlAnidado:
Inventory
$$ Variables para las pruebas
Stack contador = 0;
Stack max_iteraciones = 5;
Stack resultado = 0;
Stack opcion = 2;
Torch condicion1 = On;
Torch condicion2 = Off;
Spider mensaje = "
Estructuras
de
control
anidadas
";
Spider resultado_texto = "
";
Shelf[5] Stack matriz = [1, 2, 3, 4, 5];
Entity Personaje
PolloCrudo
Spider nombre;
Stack nivel;
Torch activo;
PolloAsado;
Entity Personaje jugador;
SpawnPoint
dropperSpider(mensaje);
jugador@nombre = "
Steve
";
jugador@nivel = 1;
jugador@activo = On;
$$ 1. Condicionales anidados (if-then-else)
target jugador@nivel >= 1 craft hit
PolloCrudo
dropperSpider("
Nivel
suficiente
para
comenzar
");
target jugador@activo craft hit
PolloCrudo
dropperSpider("
Jugador
activo
");
target jugador@nombre is "
Steve
" craft hit
PolloCrudo
dropperSpider("
Bienvenido
,
Steve
");
soulsand jugador@nivel;
PolloAsado
miss
PolloCrudo
dropperSpider("
Bienvenido
,
jugador
desconocido
");
PolloAsado
PolloAsado
miss
PolloCrudo
dropperSpider("
Jugador
inactivo
.
Activando
.
.
.
");
jugador@activo = On;
PolloAsado
PolloAsado
miss
PolloCrudo
dropperSpider("
Nivel
insuficiente
para
comenzar
");
PolloAsado
$$ 2. Switch anidado dentro de if
target opcion > 0 craft hit
PolloCrudo
jukebox opcion craft
disc 1:
PolloCrudo
dropperSpider("
Opción
1
seleccionada
");
target condicion1 craft hit
PolloCrudo
dropperSpider("
Subopción
A
");
PolloAsado
miss
PolloCrudo
dropperSpider("
Subopción
B
");
PolloAsado
PolloAsado
disc 2:
PolloCrudo
dropperSpider("
Opción
2
seleccionada
");
jukebox jugador@nivel craft
disc 1:
PolloCrudo
dropperSpider("
Nivel
básico
");
PolloAsado
disc 2:
PolloCrudo
dropperSpider("
Nivel
intermedio
");
PolloAsado
silence:
PolloCrudo
dropperSpider("
Nivel
desconocido
");
PolloAsado
PolloAsado
silence:
PolloCrudo
dropperSpider("
Opción
no
reconocida
");
PolloAsado
PolloAsado
$$ 3. Bucles anidados - while dentro de for
walk i set 0 to 2 craft
PolloCrudo
dropperSpider("
Iteración
de
for
principal
:
" bind i);
Stack j = 0;
repeater j < 3 craft
PolloCrudo
dropperSpider("
Subiteración
de
while
:
" bind j);
resultado += (i * 10 + j);
soulsand j;
PolloAsado
PolloAsado
dropperSpider("
Resultado
acumulado
:
" bind resultado);
$$ 4. Bucle do-while con if anidado
contador = 0;
resultado = 0;
spawner
PolloCrudo
soulsand contador;
dropperSpider("
Iteración
do
-
while
:
" bind contador);
target contador % 2 is 0 craft hit
PolloCrudo
dropperSpider("
Número
par
detectado
");
resultado += contador;
PolloAsado
miss
PolloCrudo
dropperSpider("
Número
impar
detectado
");
resultado += contador * 2;
PolloAsado
PolloAsado
exhausted contador >= max_iteraciones;
dropperSpider("
Resultado
tras
do
-
while
:
" bind resultado);
$$ 5. Bucles for anidados con break y continue
resultado = 0;
walk i set 0 to 5 craft
PolloCrudo
target i is 3 craft hit
PolloCrudo
dropperSpider("
Saltando
iteración
i
=
3
");
enderPearl;
PolloAsado
dropperSpider("
For
externo
:
" bind i);
walk j set 0 to 3 craft
PolloCrudo
target i is 4 and j > 1 craft hit
PolloCrudo
dropperSpider("
Terminando
loop
interno
en
i
=
4
,
j
=
" bind j);
creeper;
PolloAsado
resultado += (i + j);
dropperSpider("
For
interno
:
j
=
" bind j bind "
,
suma
acumulada
=
" bind resultado);
PolloAsado
PolloAsado
$$ 6. Combinación compleja: with dentro de if-else dentro de while
contador = 0;
resultado = 0;
repeater contador < 3 craft
PolloCrudo
soulsand contador;
dropperSpider("
Iteración
while
principal
:
" bind contador);
target contador % 2 is 0 craft hit
PolloCrudo
wither jugador craft
PolloCrudo
activo = Off;
dropperSpider("
" bind nombre bind "
desactivado
temporalmente
");
spawner
PolloCrudo
soulsand nivel;
dropperSpider("
Incrementando
nivel
:
" bind nivel);
PolloAsado
exhausted nivel > contador + 2;
activo = On;
dropperSpider("
" bind nombre bind "
reactivado
con
nivel
" bind nivel);
PolloAsado
PolloAsado
miss
PolloCrudo
Stack temp_nivel = jugador@nivel;
repeater temp_nivel > 0 craft
PolloCrudo
dropperSpider("
Reduciendo
nivel
temporal
:
" bind temp_nivel);
target temp_nivel is 1 craft hit
PolloCrudo
dropperSpider("
Nivel
mínimo
alcanzado
");
creeper;
PolloAsado
magma temp_nivel;
PolloAsado
PolloAsado
PolloAsado
$$ 7. Estructuras de control con expresiones complejas en las condiciones
walk i set 0 to matriz[2] + matriz[4] // 2 craft
PolloCrudo
target (i * 2 <= matriz[i % 5]) and ((i % 2 is 0) or (i is matriz[0])) craft hit
PolloCrudo
dropperSpider("
Condición
compleja
satisfecha
en
i
=
" bind i);
resultado += i;
PolloAsado
PolloAsado
dropperSpider("
Resultado
final
:
" bind resultado);
$$ 8. Instrucción ragequit condicionada anidada
target contador >= max_iteraciones and resultado < 100 craft hit
PolloCrudo
target jugador@nivel < 5 craft hit
PolloCrudo
dropperSpider("
Condiciones
críticas
alcanzadas
.
Terminando
programa
.
");
ragequit;
PolloAsado
PolloAsado
dropperSpider("
Programa
completado
con
éxito
.
");
worldSave
$*
Prueba: 43_Prueba_Rend_MuchosTokens
Descripción: Verificar rendimiento con un archivo con miles de tokens
Fecha: 28/04/2025
*$
WorldName PruebaMuchosTokens:
Bedrock
Obsidian Stack MAX_ITERATIONS 1000;
Obsidian Stack ARRAY_SIZE 500;
Obsidian Stack STEP_VALUE 1;
Obsidian Spider TEST_NAME "
Prueba
de
rendimiento
con
muchos
tokens
";
ResourcePack
Entity TestData
PolloCrudo
Stack id;
Stack value;
Ghast weight;
Spider name;
Torch active;
PolloAsado;
Inventory
$$ Declaramos variables extensas para generar muchos tokens
Shelf[500] Stack numbers;
$$ Creamos un array grande de registros
Shelf[100] Entity TestData records;
$$ Variables para el procesamiento
Stack counter;
Stack sum;
Stack product;
Stack max_value;
Stack min_value;
Ghast average;
Stack i;
Stack j;
Stack k;
Stack temp;
Torch condition;
SpawnPoint
dropperSpider(TEST_NAME);
dropperSpider("
Inicializando
arrays
.
.
.
");
$$ Inicialización masiva del array de enteros
walk i set 0 to ARRAY_SIZE - 1 craft
PolloCrudo
numbers[i] = i * STEP_VALUE;
PolloAsado
$$ Inicialización del array de registros
walk i set 0 to 99 craft
PolloCrudo
records[i]@id = i;
records[i]@value = i * 10;
records[i]@weight = i :* 0.5;
records[i]@name = "
Item_
" bind i;
records[i]@active = i % 2 is 0;
PolloAsado
dropperSpider("
Realizando
cálculos
.
.
.
");
$$ Cálculos repetitivos generando miles de tokens
sum = 0;
product = 1;
max_value = numbers[0];
min_value = numbers[0];
$$ Bucle con muchas operaciones
walk i set 0 to ARRAY_SIZE - 1 craft
PolloCrudo
$$ Acumuladores simples
sum += numbers[i];
$$ Para evitar overflow, sólo multiplicamos los primeros 10 valores
target i < 10 craft hit
PolloCrudo
product *= numbers[i] + 1;
PolloAsado
$$ Cálculo de máximo y mínimo
target numbers[i] > max_value craft hit
PolloCrudo
max_value = numbers[i];
PolloAsado
target numbers[i] < min_value craft hit
PolloCrudo
min_value = numbers[i];
PolloAsado
$$ Operaciones condicionales adicionales
target i % 50 is 0 craft hit
PolloCrudo
dropperSpider("
Procesado
" bind i bind "
elementos
.
.
.
");
PolloAsado
PolloAsado
$$ Cálculo de promedio
average = sum >> Ghast :// (ARRAY_SIZE >> Ghast);
dropperSpider("
Procesamiento
completado
.
Resultados
:
");
dropperSpider("
Suma
total
:
" bind sum);
dropperSpider("
Producto
(
primeros
10
)
:
" bind product);
dropperSpider("
Valor
máximo
:
" bind max_value);
dropperSpider("
Valor
mínimo
:
" bind min_value);
dropperSpider("
Promedio
:
" bind average);
$$ Procesamiento de registros - para generar más tokens
dropperSpider("
Procesando
registros
.
.
.
");
counter = 0;
walk i set 0 to 99 craft
PolloCrudo
target records[i]@active craft hit
PolloCrudo
soulsand counter;
$$ Actualizar el valor basado en otros registros
walk j set 0 to i craft
PolloCrudo
records[i]@value += j;
PolloAsado
PolloAsado
PolloAsado
dropperSpider("
Registros
activos
:
" bind counter);
$$ Algoritmo de ordenamiento burbuja para generar aún más tokens
dropperSpider("
Ordenando
array
.
.
.
");
walk i set 0 to ARRAY_SIZE - 2 craft
PolloCrudo
walk j set 0 to ARRAY_SIZE - i - 2 craft
PolloCrudo
target numbers[j] > numbers[j + 1] craft hit
PolloCrudo
$$ Intercambio
temp = numbers[j];
numbers[j] = numbers[j + 1];
numbers[j + 1] = temp;
PolloAsado
PolloAsado
PolloAsado
dropperSpider("
Array
ordenado
.
");
$$ Búsqueda binaria para generar más tokens
dropperSpider("
Realizando
búsquedas
.
.
.
");
walk k set 0 to 20 craft
PolloCrudo
Stack valor_buscar = k * 25;
Stack inicio = 0;
Stack fin = ARRAY_SIZE - 1;
Stack medio;
Stack encontrado = 0;
repeater inicio <= fin craft
PolloCrudo
medio = (inicio + fin) // 2;
target numbers[medio] is valor_buscar craft hit
PolloCrudo
encontrado = 1;
creeper;
PolloAsado
target numbers[medio] < valor_buscar craft hit
PolloCrudo
inicio = medio + 1;
PolloAsado
miss
PolloCrudo
fin = medio - 1;
PolloAsado
PolloAsado
target encontrado craft hit
PolloCrudo
dropperSpider("
Valor
" bind valor_buscar bind "
encontrado
en
posición
" bind medio);
PolloAsado
miss
PolloCrudo
dropperSpider("
Valor
" bind valor_buscar bind "
no
encontrado
");
PolloAsado
PolloAsado
dropperSpider("
Prueba
de
rendimiento
completada
.
");
worldSave
$*
Prueba: 44_Prueba_Rend_TokensRepetidos
Descripción: Verificar rendimiento con patrones repetitivos
Fecha: 28/04/2025
*$
WorldName PruebaTokensRepetidos:
Bedrock
Obsidian Stack MAX_ITERATIONS 500;
Obsidian Stack PATTERN_LENGTH 20;
Inventory
$$ Variables para la prueba
Stack counter = 0;
Stack total = 0;
Stack temp = 0;
Torch flag = On;
SpawnPoint
dropperSpider("
Iniciando
prueba
de
rendimiento
con
tokens
repetitivos
");
$$ =================================================================
$$ Patrón 1: Repetición masiva de operaciones aritméticas
$$ =================================================================
counter = 0;
total = 0;
repeater counter < MAX_ITERATIONS craft
PolloCrudo
$$ Patrón de operaciones aritméticas que se repite
total = total + 1;
total = total - 1;
total = total + 2;
total = total - 1;
total = total + 3;
total = total - 2;
total = total * 2;
total = total // 2;
total = total + 5;
total = total % 10;
total = total + 1;
total = total - 1;
total = total + 2;
total = total - 1;
total = total + 3;
total = total - 2;
total = total * 2;
total = total // 2;
total = total + 5;
total = total % 10;
soulsand counter;
PolloAsado
dropperSpider("
Patrón
1
completado
.
Total
:
" bind total);
$$ =================================================================
$$ Patrón 2: Repetición masiva de operaciones lógicas
$$ =================================================================
counter = 0;
flag = On;
repeater counter < MAX_ITERATIONS craft
PolloCrudo
$$ Patrón de operaciones lógicas que se repite
flag = flag and On;
flag = flag or Off;
flag = not flag;
flag = flag and On;
flag = flag or Off;
flag = not flag;
flag = flag xor On;
flag = flag xor Off;
flag = flag and On;
flag = not flag;
flag = flag and On;
flag = flag or Off;
flag = not flag;
flag = flag and On;
flag = flag or Off;
flag = not flag;
flag = flag xor On;
flag = flag xor Off;
flag = flag and On;
flag = not flag;
soulsand counter;
PolloAsado
dropperSpider("
Patrón
2
completado
.
Estado
final
:
" bind flag);
$$ =================================================================
$$ Patrón 3: Repetición masiva de evaluaciones condicionales
$$ =================================================================
counter = 0;
total = 0;
repeater counter < MAX_ITERATIONS craft
PolloCrudo
$$ Patrón de condicionales que se repite
target counter % 2 is 0 craft hit
PolloCrudo
total += 1;
PolloAsado
miss
PolloCrudo
total += 2;
PolloAsado
target counter % 3 is 0 craft hit
PolloCrudo
total += 3;
PolloAsado
miss
PolloCrudo
total += 1;
PolloAsado
target counter % 5 is 0 craft hit
PolloCrudo
total += 5;
PolloAsado
miss
PolloCrudo
total += 2;
PolloAsado
target counter % 7 is 0 craft hit
PolloCrudo
total += 7;
PolloAsado
miss
PolloCrudo
total += 3;
PolloAsado
target total > 1000 craft hit
PolloCrudo
total = total % 1000;
PolloAsado
soulsand counter;
PolloAsado
dropperSpider("
Patrón
3
completado
.
Total
:
" bind total);
$$ =================================================================
$$ Patrón 4: Repetición masiva de incremento/decremento
$$ =================================================================
counter = 0;
total = 500;
repeater counter < MAX_ITERATIONS craft
PolloCrudo
$$ Patrón de incremento/decremento que se repite
soulsand total;
soulsand total;
soulsand total;
magma total;
magma total;
soulsand total;
soulsand total;
magma total;
soulsand total;
magma total;
soulsand total;
soulsand total;
soulsand total;
magma total;
magma total;
soulsand total;
soulsand total;
magma total;
soulsand total;
magma total;
soulsand counter;
PolloAsado
dropperSpider("
Patrón
4
completado
.
Total
:
" bind total);
$$ =================================================================
$$ Patrón 5: Repetición masiva de operaciones de asignación compuesta
$$ =================================================================
counter = 0;
total = 5;
repeater counter < MAX_ITERATIONS craft
PolloCrudo
$$ Patrón de asignaciones compuestas que se repite
total += 5;
total -= 2;
total *= 2;
total //= 2;
total %= 10;
total += 1;
total -= 1;
total *= 3;
total //= 3;
total %= 5;
total += 5;
total -= 2;
total *= 2;
total //= 2;
total %= 10;
total += 1;
total -= 1;
total *= 3;
total //= 3;
total %= 5;
soulsand counter;
PolloAsado
dropperSpider("
Patrón
5
completado
.
Total
:
" bind total);
$$ =================================================================
$$ Patrón 6: Repetición masiva de operadores de comparación
$$ =================================================================
counter = 0;
total = 0;
temp = 50;
repeater counter < MAX_ITERATIONS craft
PolloCrudo
$$ Patrón de comparaciones que se repite
target counter < temp craft hit total += 1; PolloAsado
target counter > temp craft hit total += 1; PolloAsado
target counter <= temp craft hit total += 1; PolloAsado
target counter >= temp craft hit total += 1; PolloAsado
target counter is temp craft hit total += 1; PolloAsado
target counter isNot temp craft hit total += 1; PolloAsado
target counter < 100 craft hit total += 1; PolloAsado
target counter > 0 craft hit total += 1; PolloAsado
target counter <= 100 craft hit total += 1; PolloAsado
target counter >= 0 craft hit total += 1; PolloAsado
target counter < temp craft hit total += 1; PolloAsado
target counter > temp craft hit total += 1; PolloAsado
target counter <= temp craft hit total += 1; PolloAsado
target counter >= temp craft hit total += 1; PolloAsado
target counter is temp craft hit total += 1; PolloAsado
target counter isNot temp craft hit total += 1; PolloAsado
target counter < 100 craft hit total += 1; PolloAsado
target counter > 0 craft hit total += 1; PolloAsado
target counter <= 100 craft hit total += 1; PolloAsado
target counter >= 0 craft hit total += 1; PolloAsado
soulsand counter;
PolloAsado
dropperSpider("
Patrón
6
completado
.
Total
:
" bind total);
dropperSpider("
Prueba
de
rendimiento
con
tokens
repetitivos
completada
.
");
worldSave
$*
Prueba: 45_Prueba_Rend_TokensVariados
Descripción: Verificar rendimiento con variedad de tokens mezclados
Fecha: 28/04/2025
*$
WorldName PruebaTokensVariados:
$$ Sección de constantes para controlar el tamaño de la prueba
Bedrock
Obsidian Stack ITERATIONS 100;
Obsidian Stack MAX_VALUE 1000;
Obsidian Stack ARRAY_SIZE 50;
Obsidian Spider TEST_NAME "
Prueba
de
rendimiento
con
tokens
variados
";
Obsidian Spider VERSION "
1.0
";
Obsidian Ghast PI 3.14159;
Obsidian Torch DEBUG_MODE On;
$$ Definiciones de tipos variados para generar diversidad de tokens
ResourcePack
Entity Posicion
PolloCrudo
Stack x;
Stack y;
Stack z;
PolloAsado;
Entity Item
PolloCrudo
Spider nombre;
Stack cantidad;
Stack durabilidad;
Ghast peso;
Torch consumible;
PolloAsado;
Entity Jugador
PolloCrudo
Spider nombre;
Stack nivel;
Ghast salud;
Entity Posicion posicion;
Shelf[10] Entity Item inventario;
PolloAsado;
Anvil Ghast -> Stack truncate;
Anvil Stack -> Spider;
Anvil Spider -> Stack;
Anvil Stack -> Torch;
Inventory
Stack contador = 0;
Stack suma = 0;
Stack producto = 1;
Ghast pi = 3.14159;
Ghast e = 2.71828;
Ghast resultado_flotante = 0.0;
Spider texto = "
Prueba
de
rendimiento
";
Spider resultado_texto = "
";
Rune caracter = 'A';
Torch condicion = On;
Shelf[ARRAY_SIZE] Stack numeros;
Shelf[ARRAY_SIZE] Ghast valores_reales;
Shelf[10] Spider textos = ["
uno
", "
dos
", "
tres
", "
cuatro
", "
cinco
", "
seis
", "
siete
", "
ocho
", "
nueve
", "
diez
"];
Chest conjunto_numeros = {: 1, 2, 3, 4, 5 :};
Chest conjunto_caracteres = {: 'a', 'b', 'c', 'd', 'e' :};
Book archivo_log = {/ "
log
.
txt
", 'E' /};
Book archivo_datos = {/ "
datos
.
dat
", 'L' /};
Entity Posicion origen
PolloCrudo
x: 0;
y: 0;
z: 0;
PolloAsado;
Entity Item espada
PolloCrudo
nombre: "
Espada
de
diamante
";
cantidad: 1;
durabilidad: 1000;
peso: 5.0;
consumible: Off;
PolloAsado;
Entity Jugador jugador_principal;
Entity Jugador jugadores[5];
Recipe
Spell calcularDanio(Stack :: nivel; Ghast :: multiplicador) -> Stack;
Spell distanciaEntre(Entity Posicion :: pos1, pos2) -> Ghast;
Spell crearItem(Spider :: nombre; Stack cantidad, durabilidad; Ghast peso; Torch consumible) -> Entity Item;
Ritual inicializarJugador(Entity Jugador ref jugador; Spider :: nombre; Stack nivel; Ghast salud);
Ritual mostrarEstadisticas(Entity Jugador :: jugador);
Ritual procesarInventario(Shelf[10] Entity Item :: inventario);
CraftingTable
Spell calcularDanio(Stack :: nivel; Ghast :: multiplicador) -> Stack
PolloCrudo
Stack danio_base = nivel * 2 + 5;
Stack danio_final = danio_base;
target nivel > 10 craft hit
PolloCrudo
danio_final += (nivel - 10) * 3;
PolloAsado
Ghast temp = danio_final >> Ghast;
temp = temp :* multiplicador;
danio_final = temp >> Stack;
respawn danio_final;
PolloAsado
Spell distanciaEntre(Entity Posicion :: pos1, pos2) -> Ghast
PolloCrudo
Stack dx = pos1@x - pos2@x;
Stack dy = pos1@y - pos2@y;
Stack dz = pos1@z - pos2@z;
Ghast dx_float = dx >> Ghast;
Ghast dy_float = dy >> Ghast;
Ghast dz_float = dz >> Ghast;
Ghast suma_cuadrados = (dx_float :* dx_float) :+ (dy_float :* dy_float) :+ (dz_float :* dz_float);
Ghast result = suma_cuadrados :// 2.0;
respawn result;
PolloAsado
Spell crearItem(Spider :: nombre; Stack cantidad, durabilidad; Ghast peso; Torch consumible) -> Entity Item
PolloCrudo
Entity Item nuevo_item
PolloCrudo
nombre: nombre;
cantidad: cantidad;
durabilidad: durabilidad;
peso: peso;
consumible: consumible;
PolloAsado;
respawn nuevo_item;
PolloAsado
Ritual inicializarJugador(Entity Jugador ref jugador; Spider :: nombre; Stack nivel; Ghast salud)
PolloCrudo
jugador@nombre = nombre;
jugador@nivel = nivel;
jugador@salud = salud;
jugador@posicion@x = 0;
jugador@posicion@y = 0;
jugador@posicion@z = 0;
walk i set 0 to 9 craft
PolloCrudo
jugador@inventario[i] = crearItem("
Item_
" bind i, i + 1, 100 * (i + 1), i :* 0.5, i % 2 is 0);
PolloAsado
PolloAsado
Ritual mostrarEstadisticas(Entity Jugador :: jugador)
PolloCrudo
dropperSpider("
==
=
Estadísticas
del
Jugador
==
=
");
dropperSpider("
Nombre
:
" bind jugador@nombre);
dropperSpider("
Nivel
:
" bind jugador@nivel);
dropperSpider("
Salud
:
" bind jugador@salud);
dropperSpider("
Posición
:
(
" bind jugador@posicion@x bind "
,
" bind jugador@posicion@y bind "
,
" bind jugador@posicion@z bind "
)
");
dropperSpider("
Inventario
:
" bind #(jugador@inventario) bind "
items
");
PolloAsado
Ritual procesarInventario(Shelf[10] Entity Item :: inventario)
PolloCrudo
Stack total_items = 0;
Ghast peso_total = 0.0;
Spider lista_items = "
";
walk i set 0 to 9 craft
PolloCrudo
total_items += inventario[i]@cantidad;
peso_total = peso_total :+ (inventario[i]@peso :* inventario[i]@cantidad >> Ghast);
target i < 9 craft hit
PolloCrudo
lista_items = lista_items bind inventario[i]@nombre bind "
,
";
PolloAsado
miss
PolloCrudo
lista_items = lista_items bind inventario[i]@nombre;
PolloAsado
PolloAsado
dropperSpider("
Total
items
:
" bind total_items);
dropperSpider("
Peso
total
:
" bind peso_total);
dropperSpider("
Lista
:
" bind lista_items);
PolloAsado
SpawnPoint
dropperSpider(TEST_NAME bind "
v
" bind VERSION);
walk i set 0 to ARRAY_SIZE - 1 craft
PolloCrudo
numeros[i] = (i * i + i) % MAX_VALUE;
valores_reales[i] = i :* PI :// 10.0;
target i < 20 craft hit
PolloCrudo
add(conjunto_numeros, i * 10);
PolloAsado
PolloAsado
jugador_principal@nombre = "
Aventurero
";
jugador_principal@nivel = 25;
jugador_principal@salud = 95.5;
jugador_principal@posicion@x = 100;
jugador_principal@posicion@y = 64;
jugador_principal@posicion@z = -50;
walk i set 0 to 4 craft
PolloCrudo
Spider nombre_jugador = "
Jugador_
" bind i;
Stack nivel_inicial = 1 + i * 5;
Ghast salud_inicial = 20.0 :+ (i :* 5.0);
ender_pearl inicializarJugador(jugadores[i], nombre_jugador, nivel_inicial, salud_inicial);
PolloAsado
dropperSpider("
Realizando
operaciones
mezcladas
.
.
.
");
contador = 0;
suma = 0;
producto = 1;
resultado_texto = "
";
walk iteracion set 0 to ITERATIONS - 1 craft
PolloCrudo
Stack indice = iteracion % ARRAY_SIZE;
suma += numeros[indice];
target producto < 1000000 craft hit
PolloCrudo
producto *= (indice + 1);
PolloAsado
Ghast valor_real = valores_reales[indice];
resultado_flotante = resultado_flotante :+ valor_real;
target resultado_flotante :> 1000.0 craft hit
PolloCrudo
resultado_flotante = resultado_flotante :% 1000.0;
PolloAsado
Spider texto_iteracion = textos[iteracion % 10];
target iteracion % 5 is 0 craft hit
PolloCrudo
resultado_texto = resultado_texto bind texto_iteracion;
PolloAsado
target iteracion % 2 is 0 craft hit
PolloCrudo
caracter = etchUp(caracter);
PolloAsado
miss
PolloCrudo
caracter = etchDown(caracter);
PolloAsado
condicion = condicion xor (iteracion % 3 is 0);
target indice % 2 is 0 and condicion craft hit
PolloCrudo
soulsand contador;
PolloAsado
target iteracion % 10 is 0 craft hit
PolloCrudo
Stack danio = calcularDanio(jugador_principal@nivel, 1.5);
Ghast distancia = distanciaEntre(jugador_principal@posicion, origen);
dropperSpider("
Iteración
" bind iteracion bind "
:
Daño
=
" bind danio bind "
,
Distancia
=
" bind distancia);
PolloAsado
Stack jugador_indice = iteracion % 5;
soulsand jugadores[jugador_indice]@nivel;
target iteracion % 20 is 0 craft hit
PolloCrudo
ender_pearl mostrarEstadisticas(jugadores[jugador_indice]);
PolloAsado
PolloAsado
dropperSpider("
Prueba
completada
.
Resultados
:
");
dropperSpider("
Suma
total
:
" bind suma);
dropperSpider("
Producto
acumulado
:
" bind producto);
dropperSpider("
Resultado
flotante
:
" bind resultado_flotante);
dropperSpider("
Texto
resultante
:
" bind resultado_texto);
dropperSpider("
Caracter
final
:
" bind caracter);
dropperSpider("
Contador
incrementado
:
" bind contador);
dropperSpider("
Estado
de
condición
final
:
" bind condicion);
ender_pearl procesarInventario(jugador_principal@inventario);
dropperSpider("
Prueba
de
rendimiento
con
tokens
variados
finalizada